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

package/src/examples/sendAnywhere.contract.js

@@ -0,0 +1,171 @@
+import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
+import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { M, mustMatch } from '@endo/patterns';
+import { E } from '@endo/far';
+import { heapVowE } from '@agoric/vow/vat.js';
+import { makeStateRecord } from '@agoric/async-flow';
+import { AmountShape } from '@agoric/ertp';
+import { CosmosChainInfoShape } from '../typeGuards.js';
+import { provideOrchestration } from '../utils/start-helper.js';
+import { makeResumableAgoricNamesHack } from '../exos/agoric-names-tools.js';
+
+const { entries } = Object;
+
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {TimerService} from '@agoric/time';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Remote} from '@agoric/vow';
+ * @import {CosmosChainInfo, IBCConnectionInfo} from '../cosmos-api';
+ * @import {OrchestrationService} from '../service.js';
+ * @import {Orchestrator} from '../types.js'
+ * @import {OrchestrationAccount} from '../orchestration-api.js'
+ */
+
+/**
+ * @typedef {{
+ *   localchain: Remote<LocalChain>;
+ *   orchestrationService: Remote<OrchestrationService>;
+ *   storageNode: Remote<StorageNode>;
+ *   timerService: Remote<TimerService>;
+ *   agoricNames: Remote<NameHub>;
+ * }} OrchestrationPowers
+ */
+
+/**
+ * @param {Orchestrator} orch
+ * @param {object} ctx
+ * @param {ZCF} ctx.zcf
+ * @param {any} ctx.agoricNamesTools TODO Give this a better type
+ * @param {{ account: OrchestrationAccount<any> }} ctx.contractState
+ * @param {ZCFSeat} seat
+ * @param {object} offerArgs
+ * @param {string} offerArgs.chainName
+ * @param {string} offerArgs.destAddr
+ */
+const sendItFn = async (
+  orch,
+  { zcf, agoricNamesTools, contractState },
+  seat,
+  offerArgs,
+) => {
+  mustMatch(offerArgs, harden({ chainName: M.scalar(), destAddr: M.string() }));
+  const { chainName, destAddr } = offerArgs;
+  const { give } = seat.getProposal();
+  const [[kw, amt]] = entries(give);
+  const { denom } = await agoricNamesTools.findBrandInVBank(amt.brand);
+  const chain = await orch.getChain(chainName);
+
+  if (!contractState.account) {
+    const agoricChain = await orch.getChain('agoric');
+    contractState.account = await agoricChain.makeAccount();
+    console.log('contractState.account', contractState.account);
+  }
+
+  const info = await chain.getChainInfo();
+  console.log('info', info);
+  const { chainId } = info;
+  assert(typeof chainId === 'string', 'bad chainId');
+  const { [kw]: pmtP } = await withdrawFromSeat(zcf, seat, give);
+  await E.when(pmtP, pmt => contractState.account.deposit(pmt));
+  await contractState.account.transfer(
+    { denom, value: amt.value },
+    {
+      address: destAddr,
+      addressEncoding: 'bech32',
+      chainId,
+    },
+  );
+};
+
+export const SingleAmountRecord = M.and(
+  M.recordOf(M.string(), AmountShape, {
+    numPropertiesLimit: 1,
+  }),
+  M.not(harden({})),
+);
+
+/**
+ * @param {ZCF} zcf
+ * @param {OrchestrationPowers & {
+ *   marshaller: Marshaller;
+ * }} privateArgs
+ * @param {Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const { chainHub, orchestrate, vowTools, zone } = provideOrchestration(
+    zcf,
+    baggage,
+    privateArgs,
+    privateArgs.marshaller,
+  );
+  const agoricNamesTools = makeResumableAgoricNamesHack(zone, {
+    agoricNames: privateArgs.agoricNames,
+    vowTools,
+  });
+
+  const contractState = makeStateRecord(
+    /** @type {{ account: OrchestrationAccount<any> | undefined }} */ {
+      account: undefined,
+    },
+  );
+
+  /** @type {OfferHandler} */
+  const sendIt = orchestrate(
+    'sendIt',
+    { zcf, agoricNamesTools, contractState },
+    sendItFn,
+  );
+
+  const publicFacet = zone.exo(
+    'Send PF',
+    M.interface('Send PF', {
+      makeSendInvitation: M.callWhen().returns(InvitationShape),
+    }),
+    {
+      makeSendInvitation() {
+        return zcf.makeInvitation(
+          sendIt,
+          'send',
+          undefined,
+          M.splitRecord({ give: SingleAmountRecord }),
+        );
+      },
+    },
+  );
+
+  let nonce = 0n;
+  const ConnectionInfoShape = M.record(); // TODO
+  const creatorFacet = zone.exo(
+    'Send CF',
+    M.interface('Send CF', {
+      addChain: M.callWhen(CosmosChainInfoShape, ConnectionInfoShape).returns(
+        M.scalar(),
+      ),
+    }),
+    {
+      /**
+       * @param {CosmosChainInfo} chainInfo
+       * @param {IBCConnectionInfo} connectionInfo
+       */
+      async addChain(chainInfo, connectionInfo) {
+        const chainKey = `${chainInfo.chainId}-${(nonce += 1n)}`;
+        // when() because chainHub methods return vows. If this were inside
+        // orchestrate() the membrane would wrap/unwrap automatically.
+        const agoricChainInfo = await heapVowE.when(
+          chainHub.getChainInfo('agoric'),
+        );
+        chainHub.registerChain(chainKey, chainInfo);
+        chainHub.registerConnection(
+          agoricChainInfo.chainId,
+          chainInfo.chainId,
+          connectionInfo,
+        );
+        return chainKey;
+      },
+    },
+  );
+
+  return { publicFacet, creatorFacet };
+};

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

@@ -0,0 +1,121 @@
+export function start(zcf: ZCF, privateArgs: {
+    agoricNames: Remote<NameHub>;
+    localchain: Remote<LocalChain>;
+    marshaller: Marshaller;
+    storageNode: StorageNode;
+    timerService: TimerService;
+}, baggage: import("@agoric/vat-data").Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        /**
+         * Invitation to make an account, initialized with the give's BLD
+         */
+        makeStakeBldInvitation(): Promise<Invitation<{
+            publicSubscribers: {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<Record<unknown, unknown>>, undefined>>;
+                Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/time").TimestampRecord>, undefined>>;
+                CloseAccount(): never;
+            }>;
+            account: import("@endo/exo").Guarded<{
+                getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+                getBalances(): import("@agoric/vow").Vow<never>;
+                getPublicTopics(): {
+                    account: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
+                undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
+                deposit(payment: globalThis.Payment<"nat">): import("@agoric/vow").Vow<void>;
+                withdraw(amount: import("@agoric/ertp/src/types.js").NatAmount): import("@agoric/vow").Vow<globalThis.Payment<"nat"> | import("@agoric/vow").Vow<globalThis.Payment<"nat">>>;
+                executeTx(messages: {
+                    '@type': string;
+                }[]): import("@agoric/vow").Vow<import("@agoric/cosmic-proto").JsonSafe<{
+                    '@type': string;
+                }>[]>;
+                getAddress(): import("../orchestration-api.js").ChainAddress;
+                send(toAccount: any, amount: any): import("@agoric/vow").Vow<never>;
+                transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
+                transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
+            }>;
+        }, undefined>>;
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+            getBalances(): import("@agoric/vow").Vow<never>;
+            getPublicTopics(): {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
+            undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
+            deposit(payment: globalThis.Payment<"nat">): import("@agoric/vow").Vow<void>;
+            withdraw(amount: import("@agoric/ertp/src/types.js").NatAmount): import("@agoric/vow").Vow<globalThis.Payment<"nat"> | import("@agoric/vow").Vow<globalThis.Payment<"nat">>>;
+            executeTx(messages: {
+                '@type': string;
+            }[]): import("@agoric/vow").Vow<import("@agoric/cosmic-proto").JsonSafe<{
+                '@type': string;
+            }>[]>;
+            getAddress(): import("../orchestration-api.js").ChainAddress;
+            send(toAccount: any, amount: any): import("@agoric/vow").Vow<never>;
+            transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
+            transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
+        }>>;
+        /**
+         * Invitation to make an account, without any funds
+         */
+        makeAccountInvitationMaker(): Promise<Invitation<{
+            publicSubscribers: {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                Delegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<Record<unknown, unknown>>, undefined>>;
+                Undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/time").TimestampRecord>, undefined>>;
+                CloseAccount(): never;
+            }>;
+            account: import("@endo/exo").Guarded<{
+                getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+                getBalances(): import("@agoric/vow").Vow<never>;
+                getPublicTopics(): {
+                    account: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<import("../exos/local-orchestration-account.js").LocalChainAccountNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                delegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<Record<unknown, unknown>>;
+                undelegate(validatorAddress: string, ertpAmount: Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
+                deposit(payment: globalThis.Payment<"nat">): import("@agoric/vow").Vow<void>;
+                withdraw(amount: import("@agoric/ertp/src/types.js").NatAmount): import("@agoric/vow").Vow<globalThis.Payment<"nat"> | import("@agoric/vow").Vow<globalThis.Payment<"nat">>>;
+                executeTx(messages: {
+                    '@type': string;
+                }[]): import("@agoric/vow").Vow<import("@agoric/cosmic-proto").JsonSafe<{
+                    '@type': string;
+                }>[]>;
+                getAddress(): import("../orchestration-api.js").ChainAddress;
+                send(toAccount: any, amount: any): import("@agoric/vow").Vow<never>;
+                transfer(amount: import("../orchestration-api.js").AmountArg, destination: import("../orchestration-api.js").ChainAddress, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<void>;
+                transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
+            }>;
+        }, undefined>>;
+    }>;
+}>;
+import type { NameHub } from '@agoric/vats';
+import type { Remote } from '@agoric/internal';
+import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { TimerService } from '@agoric/time';
+//# sourceMappingURL=stakeBld.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stakeBld.contract.d.ts","sourceRoot":"","sources":["stakeBld.contract.js"],"names":[],"mappings":"AAkCO,2BAVI,GAAG,eACH;IACV,WAAe,EAAE,OAAO,OAAO,CAAC,CAAC;IACjC,UAAc,EAAE,OAAO,UAAU,CAAC,CAAC;IACnC,UAAc,EAAE,UAAU,CAAC;IAC3B,WAAe,EAAE,WAAW,CAAC;IAC7B,YAAgB,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO,kBAAkB,EAAE,OAAO;;QAiDvC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8BH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBR;6BArHyB,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;kCAD9B,cAAc"}

package/src/examples/stakeBld.contract.js

@@ -0,0 +1,133 @@
+/**
+ * @file Stake BLD contract
+ */
+import { makeTracer } from '@agoric/internal';
+import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
+import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
+import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+import { prepareVowTools, heapVowE as E } from '@agoric/vow/vat.js';
+import { deeplyFulfilled } from '@endo/marshal';
+import { M } from '@endo/patterns';
+import { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
+import { makeChainHub } from '../exos/chain-hub.js';
+
+/**
+ * @import {NameHub} from '@agoric/vats';
+ * @import {Remote} from '@agoric/internal';
+ * @import {TimerService} from '@agoric/time';
+ * @import {LocalChain} from '@agoric/vats/src/localchain.js';
+ */
+
+const trace = makeTracer('StakeBld');
+
+/**
+ * @param {ZCF} zcf
+ * @param {{
+ *   agoricNames: Remote<NameHub>;
+ *   localchain: Remote<LocalChain>;
+ *   marshaller: Marshaller;
+ *   storageNode: StorageNode;
+ *   timerService: TimerService;
+ * }} privateArgs
+ * @param {import('@agoric/vat-data').Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const zone = makeDurableZone(baggage);
+
+  const { makeRecorderKit } = prepareRecorderKitMakers(
+    baggage,
+    privateArgs.marshaller,
+  );
+  const vowTools = prepareVowTools(zone.subZone('vows'));
+
+  const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
+    zone,
+    makeRecorderKit,
+    zcf,
+    privateArgs.timerService,
+    vowTools,
+    makeChainHub(privateArgs.agoricNames),
+  );
+
+  // ----------------
+  // All `prepare*` calls should go above this line.
+
+  const BLD = zcf.getTerms().brands.In;
+  const bldAmountShape = await E(BLD).getAmountShape();
+
+  async function makeLocalAccountKit() {
+    const account = await E(privateArgs.localchain).makeAccount();
+    const address = await E(account).getAddress();
+    // FIXME 'address' is implied by 'account'; use an async maker that get the value itself
+    return makeLocalOrchestrationAccountKit({
+      account,
+      address: harden({
+        address,
+        addressEncoding: 'bech32',
+        chainId: 'local',
+      }),
+      storageNode: privateArgs.storageNode,
+    });
+  }
+
+  const publicFacet = zone.exo(
+    'StakeBld',
+    M.interface('StakeBldI', {
+      makeAccount: M.callWhen().returns(M.remotable('LocalChainAccountHolder')),
+      makeAccountInvitationMaker: M.callWhen().returns(InvitationShape),
+      makeStakeBldInvitation: M.callWhen().returns(InvitationShape),
+    }),
+    {
+      /**
+       * Invitation to make an account, initialized with the give's BLD
+       */
+      makeStakeBldInvitation() {
+        return zcf.makeInvitation(
+          async seat => {
+            const { give } = seat.getProposal();
+            trace('makeStakeBldInvitation', give);
+            const { holder, invitationMakers } = await makeLocalAccountKit();
+            const { In } = await deeplyFulfilled(
+              withdrawFromSeat(zcf, seat, give),
+            );
+            await E(holder).deposit(In);
+            seat.exit();
+            return harden({
+              publicSubscribers: holder.getPublicTopics(),
+              invitationMakers,
+              account: holder,
+            });
+          },
+          'wantStake',
+          undefined,
+          M.splitRecord({
+            give: { In: bldAmountShape },
+          }),
+        );
+      },
+      async makeAccount() {
+        trace('makeAccount');
+        const { holder } = await makeLocalAccountKit();
+        return holder;
+      },
+      /**
+       * Invitation to make an account, without any funds
+       */
+      makeAccountInvitationMaker() {
+        trace('makeCreateAccountInvitation');
+        return zcf.makeInvitation(async seat => {
+          seat.exit();
+          const { holder, invitationMakers } = await makeLocalAccountKit();
+          return harden({
+            publicSubscribers: holder.getPublicTopics(),
+            invitationMakers,
+            account: holder,
+          });
+        }, 'wantLocalChainAccount');
+      },
+    },
+  );
+
+  return { publicFacet };
+};

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

@@ -0,0 +1,93 @@
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {IBCConnectionID} from '@agoric/vats';
+ * @import {TimerService} from '@agoric/time';
+ * @import {ICQConnection, OrchestrationService} from '../types.js';
+ */
+/** @type {ContractMeta<typeof start>} */
+export const meta: ContractMeta<typeof start>;
+export const privateArgsShape: {
+    orchestration: globalThis.Pattern;
+    storageNode: globalThis.Pattern;
+    marshaller: globalThis.Pattern;
+    timer: globalThis.Pattern;
+} | undefined;
+export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
+    orchestration: OrchestrationService;
+    storageNode: StorageNode;
+    marshaller: Marshaller;
+    timer: TimerService;
+}, baggage: Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        makeAccount(): Promise<import("@endo/exo").Guarded<{
+            asContinuingOffer(): {
+                publicSubscribers: {
+                    account: {
+                        description: string;
+                        subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
+                        storagePath: Promise<string>;
+                    };
+                };
+                invitationMakers: import("@endo/exo").Guarded<{
+                    Delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<import("@agoric/vow").Vow<undefined>, undefined>>;
+                    Redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<import("@agoric/vow").Vow<undefined>, undefined>>;
+                    WithdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<Invitation<import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>, undefined>>;
+                    Undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Promise<Invitation<import("@agoric/vow").Vow<undefined>, undefined>>;
+                    CloseAccount(): never;
+                    TransferAccount(): never;
+                }>;
+                holder: import("@endo/exo").Guarded<any>;
+            };
+            getPublicTopics(): {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            getAddress(): import("../orchestration-api.js").ChainAddress;
+            delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<undefined>;
+            deposit(payment: any): void;
+            getBalances(): import("@agoric/vow").Vow<never>;
+            redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<undefined>;
+            withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
+            getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
+            send(toAccount: any, amount: any): import("@agoric/vow").Vow<never>;
+            transfer(amount: any, msg: any): import("@agoric/vow").Vow<never>;
+            transferSteps(amount: any, msg: any): import("@agoric/vow").Vow<never>;
+            withdrawRewards(): import("@agoric/vow").Vow<never>;
+            undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): import("@agoric/vow").Vow<undefined>;
+        }>>;
+        makeAccountInvitationMaker(): Promise<Invitation<{
+            publicSubscribers: {
+                account: {
+                    description: string;
+                    subscriber: globalThis.Subscriber<import("../exos/cosmos-orchestration-account.js").ComosOrchestrationAccountNotification>;
+                    storagePath: Promise<string>;
+                };
+            };
+            invitationMakers: import("@endo/exo").Guarded<{
+                Delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<import("@agoric/vow").Vow<undefined>, undefined>>;
+                Redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<import("@agoric/vow").Vow<undefined>, undefined>>;
+                WithdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<Invitation<import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>, undefined>>;
+                Undelegate(delegations: Omit<import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation, "delegatorAddress">[]): Promise<Invitation<import("@agoric/vow").Vow<undefined>, undefined>>;
+                CloseAccount(): never;
+                TransferAccount(): never;
+            }>;
+            holder: import("@endo/exo").Guarded<any>;
+        }, undefined>>;
+    }>;
+}>;
+export type StakeIcaTerms = {
+    chainId: string;
+    hostConnectionId: IBCConnectionID;
+    controllerConnectionId: IBCConnectionID;
+    bondDenom: string;
+    icqEnabled: boolean;
+};
+export type StakeIcaSF = typeof start;
+import type { OrchestrationService } from '../types.js';
+import type { TimerService } from '@agoric/time';
+import type { Baggage } from '@agoric/vat-data';
+import type { IBCConnectionID } from '@agoric/vats';
+//# sourceMappingURL=stakeIca.contract.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stakeIca.contract.d.ts","sourceRoot":"","sources":["stakeIca.contract.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAelC;AACH;;;;;cAAsD;AAsB/C,2BATI,GAAG,CAAC,aAAa,CAAC,eAClB;IACV,aAAiB,EAAE,oBAAoB,CAAC;IACxC,WAAe,EAAE,WAAW,CAAC;IAC7B,UAAc,EAAE,UAAU,CAAC;IAC3B,KAAS,EAAE,YAAY,CAAC;CACrB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkFjB;4BAnGY;IACZ,OAAW,EAAE,MAAM,CAAC;IACpB,gBAAoB,EAAE,eAAe,CAAC;IACtC,sBAA0B,EAAE,eAAe,CAAC;IAC5C,SAAa,EAAE,MAAM,CAAC;IACtB,UAAc,EAAE,OAAO,CAAC;CACrB;yBA+FU,OAAO,KAAK;0CA3H4B,aAAa;kCADpC,cAAc;6BAFnB,kBAAkB;qCACV,cAAc"}

package/src/examples/stakeIca.contract.js

@@ -0,0 +1,143 @@
+/** @file Example contract that uses orchestration */
+
+import { makeTracer, StorageNodeShape } from '@agoric/internal';
+import { TimerServiceShape } from '@agoric/time';
+import { heapVowE as E, prepareVowTools } from '@agoric/vow/vat.js';
+import {
+  prepareRecorderKitMakers,
+  provideAll,
+} from '@agoric/zoe/src/contractSupport';
+import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
+import { makeDurableZone } from '@agoric/zone/durable.js';
+import { M } from '@endo/patterns';
+import { prepareCosmosOrchestrationAccount } from '../exos/cosmos-orchestration-account.js';
+
+const trace = makeTracer('StakeIca');
+/**
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {IBCConnectionID} from '@agoric/vats';
+ * @import {TimerService} from '@agoric/time';
+ * @import {ICQConnection, OrchestrationService} from '../types.js';
+ */
+
+/** @type {ContractMeta<typeof start>} */
+export const meta = harden({
+  customTermsShape: {
+    chainId: M.string(),
+    hostConnectionId: M.string(),
+    controllerConnectionId: M.string(),
+    bondDenom: M.string(),
+    icqEnabled: M.boolean(),
+  },
+  privateArgsShape: {
+    orchestration: M.remotable('orchestration'),
+    storageNode: StorageNodeShape,
+    marshaller: M.remotable('marshaller'),
+    timer: TimerServiceShape,
+  },
+});
+export const privateArgsShape = meta.privateArgsShape;
+
+/**
+ * @typedef {{
+ *   chainId: string;
+ *   hostConnectionId: IBCConnectionID;
+ *   controllerConnectionId: IBCConnectionID;
+ *   bondDenom: string;
+ *   icqEnabled: boolean;
+ * }} StakeIcaTerms
+ */
+
+/**
+ * @param {ZCF<StakeIcaTerms>} zcf
+ * @param {{
+ *   orchestration: OrchestrationService;
+ *   storageNode: StorageNode;
+ *   marshaller: Marshaller;
+ *   timer: TimerService;
+ * }} privateArgs
+ * @param {Baggage} baggage
+ */
+export const start = async (zcf, privateArgs, baggage) => {
+  const {
+    chainId,
+    hostConnectionId,
+    controllerConnectionId,
+    bondDenom,
+    icqEnabled,
+  } = zcf.getTerms();
+  const { orchestration, marshaller, storageNode, timer } = privateArgs;
+
+  const zone = makeDurableZone(baggage);
+
+  const { accountsStorageNode } = await provideAll(baggage, {
+    accountsStorageNode: () => E(storageNode).makeChildNode('accounts'),
+  });
+
+  const { makeRecorderKit } = prepareRecorderKitMakers(baggage, marshaller);
+
+  const vowTools = prepareVowTools(zone.subZone('vows'));
+
+  const makeCosmosOrchestrationAccount = prepareCosmosOrchestrationAccount(
+    zone,
+    makeRecorderKit,
+    vowTools,
+    zcf,
+  );
+
+  async function makeAccountKit() {
+    const account = await E(orchestration).makeAccount(
+      chainId,
+      hostConnectionId,
+      controllerConnectionId,
+    );
+    // TODO permissionless queries https://github.com/Agoric/agoric-sdk/issues/9326
+    const icqConnection = icqEnabled
+      ? await E(orchestration).provideICQConnection(controllerConnectionId)
+      : undefined;
+
+    const accountAddress = await E(account).getAddress();
+    trace('account address', accountAddress);
+    const accountNode = await E(accountsStorageNode).makeChildNode(
+      accountAddress.address,
+    );
+    const holder = makeCosmosOrchestrationAccount(accountAddress, bondDenom, {
+      account,
+      storageNode: accountNode,
+      icqConnection,
+      timer,
+    });
+    return holder;
+  }
+
+  const publicFacet = zone.exo(
+    'StakeAtom',
+    M.interface('StakeAtomI', {
+      makeAccount: M.callWhen().returns(M.remotable('ChainAccount')),
+      makeAccountInvitationMaker: M.callWhen().returns(InvitationShape),
+    }),
+    {
+      async makeAccount() {
+        trace('makeAccount');
+        return makeAccountKit();
+      },
+      makeAccountInvitationMaker() {
+        trace('makeCreateAccountInvitation');
+        return zcf.makeInvitation(
+          async seat => {
+            seat.exit();
+            const holder = await makeAccountKit();
+            return holder.asContinuingOffer();
+          },
+          'wantStakingAccount',
+          undefined,
+          undefined,
+        );
+      },
+    },
+  );
+
+  return { publicFacet };
+};
+
+/** @typedef {typeof start} StakeIcaSF */