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

package/src/proposals/revise-chain-info.js

@@ -0,0 +1,44 @@
+import { makeTracer } from '@agoric/internal';
+import { registerChain } from '../chain-info.js';
+
+const trace = makeTracer('ReviseChainInfo', true);
+
+/** @import {CosmosChainInfo} from '../types.js'; */
+
+/**
+ * This will add news values AND overwrite any existing values. Voters on a
+ * proposal of core-eval must be careful not to overwrite any values operating
+ * in production.
+ *
+ * @param {BootstrapPowers} powers
+ * @param {{ options: { chainInfo: Record<string, CosmosChainInfo> } }} opt
+ */
+export const reviseChainInfo = async (
+  { consume: { agoricNamesAdmin } },
+  { options: { chainInfo } },
+) => {
+  trace('init-chainInfo');
+
+  assert(chainInfo, 'chainInfo is required');
+
+  trace(chainInfo);
+
+  // Now register the names
+  for await (const [name, info] of Object.entries(chainInfo)) {
+    await registerChain(agoricNamesAdmin, name, info, trace);
+  }
+};
+harden(reviseChainInfo);
+
+export const getManifestForReviseChains = (_powers, { chainInfo }) => ({
+  manifest: {
+    [reviseChainInfo.name]: {
+      consume: {
+        agoricNamesAdmin: true,
+      },
+    },
+  },
+  options: {
+    chainInfo,
+  },
+});

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

@@ -0,0 +1,109 @@
+export function startStakeAtom({ consume: { agoricNames, board, chainStorage, chainTimerService, orchestration, startUpgradable, }, installation: { consume: { stakeIca }, }, instance: { produce: { stakeAtom: produceInstance }, }, }: BootstrapPowers & {
+    installation: {
+        consume: {
+            stakeIca: Installation<(zcf: ZCF<StakeIcaTerms>, privateArgs: {
+                orchestration: import("../service.js").OrchestrationService;
+                storageNode: StorageNode;
+                marshaller: Marshaller;
+                timer: import("@agoric/time").TimerService;
+            }, baggage: import("@agoric/vat-data").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>>;
+                }>;
+            }>>;
+        };
+    };
+}): Promise<void>;
+export function getManifestForStakeAtom({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys, ...options }: {
+    [x: string]: any;
+    installKeys: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNames: boolean;
+                board: boolean;
+                chainStorage: boolean;
+                chainTimerService: boolean;
+                orchestration: boolean;
+                startUpgradable: boolean;
+            };
+            installation: {
+                consume: {
+                    stakeIca: boolean;
+                };
+            };
+            instance: {
+                produce: {
+                    stakeAtom: boolean;
+                };
+            };
+        };
+    };
+    installations: {
+        stakeIca: any;
+    };
+    options: {
+        [x: string]: any;
+    };
+};
+import type { StakeIcaTerms } from '../examples/stakeIca.contract';
+//# sourceMappingURL=start-stakeAtom.d.ts.map

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

@@ -0,0 +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,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA0D,CACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAoDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;mCAjG4C,+BAA+B"}

package/src/proposals/start-stakeAtom.js

@@ -0,0 +1,105 @@
+import { makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { heapVowE as E } from '@agoric/vow/vat.js';
+import { makeChainHub } from '../exos/chain-hub.js';
+
+/**
+ * @import {IBCConnectionID} from '@agoric/vats';
+ * @import {StakeIcaSF,  StakeIcaTerms} from '../examples/stakeIca.contract';
+ */
+
+const trace = makeTracer('StartStakeAtom', true);
+
+/**
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       stakeIca: Installation<
+ *         import('../examples/stakeIca.contract.js').start
+ *       >;
+ *     };
+ *   };
+ * }} powers
+ */
+export const startStakeAtom = async ({
+  consume: {
+    agoricNames,
+    board,
+    chainStorage,
+    chainTimerService,
+    orchestration,
+    startUpgradable,
+  },
+  installation: {
+    consume: { stakeIca },
+  },
+  instance: {
+    produce: { stakeAtom: produceInstance },
+  },
+}) => {
+  const VSTORAGE_PATH = 'stakeAtom';
+  trace('startStakeAtom');
+  await null;
+
+  const storageNode = await makeStorageNodeChild(chainStorage, VSTORAGE_PATH);
+  const marshaller = await E(board).getPublishingMarshaller();
+
+  const chainHub = makeChainHub(await agoricNames);
+
+  const [_, cosmoshub, connectionInfo] = await E.when(
+    chainHub.getChainsAndConnection('agoric', 'cosmoshub'),
+  );
+
+  /** @type {StartUpgradableOpts<StakeIcaSF>} */
+  const startOpts = {
+    label: 'stakeAtom',
+    installation: stakeIca,
+    terms: {
+      chainId: cosmoshub.chainId,
+      hostConnectionId: connectionInfo.id,
+      controllerConnectionId: connectionInfo.counterparty.connection_id,
+      bondDenom: cosmoshub.stakingTokens[0].denom,
+      icqEnabled: cosmoshub.icqEnabled,
+    },
+    privateArgs: {
+      orchestration: await orchestration,
+      storageNode,
+      marshaller,
+      timer: await chainTimerService,
+    },
+  };
+
+  const { instance } = await E(startUpgradable)(startOpts);
+  produceInstance.resolve(instance);
+};
+harden(startStakeAtom);
+
+export const getManifestForStakeAtom = (
+  { restoreRef },
+  { installKeys, ...options },
+) => {
+  return {
+    manifest: {
+      [startStakeAtom.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          orchestration: true,
+          startUpgradable: true,
+        },
+        installation: {
+          consume: { stakeIca: true },
+        },
+        instance: {
+          produce: { stakeAtom: true },
+        },
+      },
+    },
+    installations: {
+      stakeIca: restoreRef(installKeys.stakeIca),
+    },
+    options,
+  };
+};

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

@@ -0,0 +1,154 @@
+export function startStakeBld({ consume: { agoricNames: agoricNamesP, board, chainStorage, chainTimerService: chainTimerServiceP, localchain, startUpgradable, }, installation: { consume: { stakeBld }, }, instance: { produce: { stakeBld: produceInstance }, }, issuer: { consume: { [Stake.symbol]: stakeIssuer }, }, }: BootstrapPowers & {
+    installation: {
+        consume: {
+            stakeBld: Installation<(zcf: ZCF, privateArgs: {
+                agoricNames: import("@agoric/internal").Remote<import("@agoric/vats").NameHub>;
+                localchain: import("@agoric/internal").Remote<import("@agoric/vats/src/localchain.js").LocalChain>;
+                marshaller: Marshaller;
+                storageNode: StorageNode;
+                timerService: import("@agoric/time").TimerService;
+            }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+                publicFacet: import("@endo/exo").Guarded<{
+                    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>;
+                    }>>;
+                    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>>;
+                }>;
+            }>>;
+        };
+    };
+}): Promise<void>;
+export function getManifestForStakeBld({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys }: {
+    installKeys: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNames: boolean;
+                board: boolean;
+                chainStorage: boolean;
+                chainTimerService: boolean;
+                localchain: boolean;
+                startUpgradable: boolean;
+            };
+            installation: {
+                consume: {
+                    stakeBld: boolean;
+                };
+            };
+            instance: {
+                produce: {
+                    stakeBld: boolean;
+                };
+            };
+            issuer: {
+                consume: {
+                    BLD: boolean;
+                };
+            };
+        };
+    };
+    installations: {
+        stakeBld: any;
+    };
+};
+import { Stake } from '@agoric/internal/src/tokens.js';
+//# sourceMappingURL=start-stakeBld.d.ts.map

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

@@ -0,0 +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,CAC9B;;;;;;+BAiCqB,kBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAjC2B,CACxD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAwDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2BN;sBApGqB,gCAAgC"}

package/src/proposals/start-stakeBld.js

@@ -0,0 +1,103 @@
+import { makeTracer } from '@agoric/internal';
+import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
+import { Stake } from '@agoric/internal/src/tokens.js';
+import { E } from '@endo/far';
+
+const trace = makeTracer('StartStakeBld', true);
+
+/**
+ * @param {BootstrapPowers & {
+ *   installation: {
+ *     consume: {
+ *       stakeBld: Installation<
+ *         import('../../src/examples/stakeBld.contract.js').start
+ *       >;
+ *     };
+ *   };
+ * }} powers
+ */
+export const startStakeBld = async ({
+  consume: {
+    agoricNames: agoricNamesP,
+    board,
+    chainStorage,
+    chainTimerService: chainTimerServiceP,
+    localchain,
+    startUpgradable,
+  },
+  installation: {
+    consume: { stakeBld },
+  },
+  instance: {
+    produce: { stakeBld: produceInstance },
+  },
+  issuer: {
+    consume: { [Stake.symbol]: stakeIssuer },
+  },
+}) => {
+  const VSTORAGE_PATH = 'stakeBld';
+  trace('startStakeBld');
+
+  const storageNode = await makeStorageNodeChild(chainStorage, VSTORAGE_PATH);
+
+  // NB: committee must only publish what it intended to be public
+  const marshaller = await E(board).getPublishingMarshaller();
+
+  const [agoricNames, timerService] = await Promise.all([
+    agoricNamesP,
+    chainTimerServiceP,
+  ]);
+
+  /**
+   * @type {StartUpgradableOpts<
+   *   import('../../src/examples/stakeBld.contract.js').start
+   * >}
+   */
+  const startOpts = {
+    label: 'stakeBld',
+    installation: stakeBld,
+    issuerKeywordRecord: harden({ In: await stakeIssuer }),
+    terms: {},
+    privateArgs: {
+      agoricNames,
+      localchain: await localchain,
+      timerService,
+      storageNode,
+      marshaller,
+    },
+  };
+
+  const { instance } = await E(startUpgradable)(startOpts);
+  produceInstance.resolve(instance);
+  trace('done');
+};
+harden(startStakeBld);
+
+export const getManifestForStakeBld = ({ restoreRef }, { installKeys }) => {
+  return {
+    manifest: {
+      [startStakeBld.name]: {
+        consume: {
+          agoricNames: true,
+          board: true,
+          chainStorage: true,
+          chainTimerService: true,
+          localchain: true,
+          startUpgradable: true,
+        },
+        installation: {
+          consume: { stakeBld: true },
+        },
+        instance: {
+          produce: { stakeBld: true },
+        },
+        issuer: {
+          consume: { [Stake.symbol]: true },
+        },
+      },
+    },
+    installations: {
+      stakeBld: restoreRef(installKeys.stakeBld),
+    },
+  };
+};

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

@@ -0,0 +1,108 @@
+export function startStakeOsmo({ consume: { agoricNames, board, chainStorage, chainTimerService, orchestration, startUpgradable, }, installation: { consume: { stakeIca }, }, instance: { produce: { stakeOsmo: produceInstance }, }, }: BootstrapPowers & {
+    installation: {
+        consume: {
+            stakeIca: Installation<(zcf: ZCF<StakeIcaTerms>, privateArgs: {
+                orchestration: import("../service.js").OrchestrationService;
+                storageNode: StorageNode;
+                marshaller: Marshaller;
+                timer: import("@agoric/time").TimerService;
+            }, baggage: import("@agoric/vat-data").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>>;
+                }>;
+            }>>;
+        };
+    };
+}): Promise<void>;
+export function getManifestForStakeOsmo({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys, ...options }: {
+    [x: string]: any;
+    installKeys: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                agoricNames: boolean;
+                board: boolean;
+                chainStorage: boolean;
+                chainTimerService: boolean;
+                orchestration: boolean;
+                startUpgradable: boolean;
+            };
+            installation: {
+                consume: {
+                    stakeIca: boolean;
+                };
+            };
+            instance: {
+                produce: {
+                    stakeOsmo: boolean;
+                };
+            };
+        };
+    };
+    installations: {
+        stakeIca: any;
+    };
+    options: {
+        [x: string]: any;
+    };
+};
+//# sourceMappingURL=start-stakeOsmo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"start-stakeOsmo.d.ts","sourceRoot":"","sources":["start-stakeOsmo.js"],"names":[],"mappings":"AAuBO,yOAVI,eAAe,GAAG;IAC5B,YAAgB,EAAE;QAClB,OAAa,EAAE;YACf,QAAgB,EAAE,YAAY,CAC9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAA0D,CACjD,CAAC;SACH,CAAC;KACH,CAAC;CACH,iBAqDH;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN"}