@agoric/orchestration 0.1.1-dev-6b5e706.0 → 0.1.1-dev-2dc53d7.0

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

@@ -0,0 +1,115 @@
+export function startStakeAtom({ consume: { agoricNames, board, chainStorage, chainTimerService, orchestration, startUpgradable, }, installation: { consume: { stakeAtom }, }, instance: { produce: { stakeAtom: produceInstance }, }, }: BootstrapPowers & {
+    installation: {
+        consume: {
+            stakeAtom: Installation<(zcf: ZCF<StakeAtomTerms>, privateArgs: {
+                orchestration: import("@endo/exo").Guarded<{
+                    makeAccount(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").Base64Any<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
+                    }>>;
+                }>;
+                storageNode: globalThis.StorageNode;
+                marshaller: {
+                    toCapData: import("@endo/marshal").ToCapData<unknown>;
+                    fromCapData: import("@endo/marshal").FromCapData<unknown>;
+                    serialize: import("@endo/marshal").ToCapData<unknown>;
+                    unserialize: import("@endo/marshal").FromCapData<unknown>;
+                };
+                timer: import("@agoric/time").TimerService;
+            }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+                publicFacet: import("@endo/exo").Guarded<{
+                    makeAccount(): Promise<import("@endo/exo").Guarded<{
+                        getPublicTopics(): {
+                            account: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<import("../exos/stakingAccountKit.js").StakingAccountNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        getAddress(): import("../orchestration-api.js").ChainAddress;
+                        delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<void>;
+                        redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<void>;
+                        withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<import("../orchestration-api.js").DenomAmount[]>;
+                        getBalance(denom?: string | undefined): Promise<import("../orchestration-api.js").DenomAmount>;
+                        withdrawRewards(): never;
+                        undelegate(delegations: import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation[]): Promise<void>;
+                    }>>;
+                    makeAcountInvitationMaker(): Promise<Invitation<{
+                        publicSubscribers: {
+                            account: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<import("../exos/stakingAccountKit.js").StakingAccountNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        invitationMakers: import("@endo/exo").Guarded<{
+                            Delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: Amount<"nat">): Promise<Invitation<void, undefined>>;
+                            Redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<Invitation<void, undefined>>;
+                            WithdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<Invitation<import("../orchestration-api.js").DenomAmount[], undefined>>;
+                            Undelegate(delegations: import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation[]): Promise<Invitation<void, undefined>>;
+                            CloseAccount(): never;
+                            TransferAccount(): never;
+                        }>;
+                        account: import("@endo/exo").Guarded<{
+                            getPublicTopics(): {
+                                account: {
+                                    description: string;
+                                    subscriber: globalThis.Subscriber<import("../exos/stakingAccountKit.js").StakingAccountNotification>;
+                                    storagePath: Promise<string>;
+                                };
+                            };
+                            getAddress(): import("../orchestration-api.js").ChainAddress;
+                            delegate(validator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<void>;
+                            redelegate(srcValidator: import("../cosmos-api.js").CosmosValidatorAddress, dstValidator: import("../cosmos-api.js").CosmosValidatorAddress, amount: import("../orchestration-api.js").AmountArg): Promise<void>;
+                            withdrawReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): Promise<import("../orchestration-api.js").DenomAmount[]>;
+                            getBalance(denom?: string | undefined): Promise<import("../orchestration-api.js").DenomAmount>;
+                            withdrawRewards(): never;
+                            undelegate(delegations: import("@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js").Delegation[]): Promise<void>;
+                        }>;
+                    }, undefined>>;
+                }>;
+            }>>;
+        };
+    };
+}, { options: { hostConnectionId, controllerConnectionId, bondDenom } }: {
+    options: StakeAtomTerms;
+}): 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: {
+                    stakeAtom: boolean;
+                };
+            };
+            instance: {
+                produce: {
+                    stakeAtom: boolean;
+                };
+            };
+        };
+    };
+    installations: {
+        stakeAtom: any;
+    };
+    options: {
+        [x: string]: any;
+    };
+};
+import type { StakeAtomTerms } from '../examples/stakeAtom.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":"AAYO,0OAHI,eAAe,GAAG;IAAE,YAAY,EAAE;QAAC,OAAO,EAAE;YAAC,SAAS,EAAE,YAAY,OA+BjE,IAAK,cAAa,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2GAwD+lJ,OAAO,KAAK,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;eAvF3gJ,CAAA;SAAC,CAAA;KAAC,CAAA;CAAC;;kBAuDpI;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BN;oCA3FgD,gCAAgC"}

package/src/proposals/start-stakeAtom.js

@@ -1,4 +1,3 @@
-// @ts-check
 import { makeTracer } from '@agoric/internal';
 import { makeStorageNodeChild } from '@agoric/internal/src/lib-chainStorage.js';
 import { E } from '@endo/far';

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

@@ -0,0 +1,80 @@
+export function startStakeBld({ consume: { board, chainStorage, localchain, startUpgradable }, installation: { consume: { stakeBld }, }, instance: { produce: { stakeBld: produceInstance }, }, issuer: { consume: { [Stake.symbol]: stakeIssuer }, }, }: BootstrapPowers & {
+    installation: {
+        consume: {
+            stakeBld: Installation<(zcf: ZCF, privateArgs: {
+                localchain: import("@agoric/vats/src/localchain.js").LocalChain;
+                marshaller: Marshaller;
+                storageNode: StorageNode;
+            }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
+                publicFacet: import("@endo/exo").Guarded<{
+                    makeStakeBldInvitation(): Promise<Invitation<{
+                        publicSubscribers: {
+                            account: {
+                                description: string;
+                                subscriber: globalThis.Subscriber<import("../exos/localchainAccountKit.js").LocalChainAccountNotification>;
+                                storagePath: Promise<string>;
+                            };
+                        };
+                        invitationMakers: import("@endo/exo").Guarded<{
+                            Delegate(validatorAddress: any, amount: any): Promise<Invitation<(import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
+                                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
+                            })[], undefined>>;
+                            CloseAccount(): never;
+                            TransferAccount(): never;
+                        }>;
+                        account: import("@endo/exo").Guarded<{
+                            getPublicTopics(): {
+                                account: {
+                                    description: string;
+                                    subscriber: globalThis.Subscriber<import("../exos/localchainAccountKit.js").LocalChainAccountNotification>;
+                                    storagePath: Promise<string>;
+                                };
+                            };
+                            makeDelegateInvitation(validatorAddress: string, ertpAmount: Amount<"nat">): Promise<Invitation<(import("@agoric/cosmic-proto/cosmos/staking/v1beta1/tx.js").MsgDelegateResponse & {
+                                '@type': "/cosmos.staking.v1beta1.MsgDelegateResponse";
+                            })[], undefined>>;
+                            makeCloseAccountInvitation(): never;
+                            makeTransferAccountInvitation(): never;
+                        }>;
+                    }, undefined>>;
+                }>;
+            }>>;
+        };
+    };
+}): Promise<void>;
+export function getManifestForStakeBld({ restoreRef }: {
+    restoreRef: any;
+}, { installKeys }: {
+    installKeys: any;
+}): {
+    manifest: {
+        [x: string]: {
+            consume: {
+                board: boolean;
+                chainStorage: 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":"AAUO,0PAFI,eAAe,GAAG;IAAC,YAAY,EAAE;QAAC,OAAO,EAAE;YAAC,QAAQ,EAAE,YAAY,OAI3E,GAAA,eACE;gBAAA,YAAe,OACjB,gCAEW,EAAE,UAAU,CAAC;gBAAA,YACxB,UACG,CAAC;gBAAA,aACO,WAAW,CAAC;aAAK,WAE1B,OACD,kBAAkB,EAAG,OAAM;;;;;;;;;;;;;;;;;;;;;;;;;yFAqDuhD,OAAO,KAAK,CAAC;;;;;;;;eAnE57C,CAAA;SAAC,CAAA;KAAC,CAAA;CAAC,iBAsCxI;AAGM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBN;sBAxEqB,gCAAgC"}

package/src/proposals/start-stakeBld.js

@@ -6,7 +6,7 @@ import { E } from '@endo/far';
 const trace = makeTracer('StartStakeBld', true);
 
 /**
- * @param {BootstrapPowers & {installation: {consume: {stakeBld: Installation<import('../../test/examples/stakeBld.contract.js').start>}}}} powers
+ * @param {BootstrapPowers & {installation: {consume: {stakeBld: Installation<import('../../src/examples/stakeBld.contract.js').start>}}}} powers
  */
 export const startStakeBld = async ({
   consume: { board, chainStorage, localchain, startUpgradable },
@@ -29,7 +29,7 @@ export const startStakeBld = async ({
   const marshaller = await E(board).getPublishingMarshaller();
 
   // FIXME this isn't detecting missing privateArgs
-  /** @type {StartUpgradableOpts<import('../../test/examples/stakeBld.contract.js').start>} */
+  /** @type {StartUpgradableOpts<import('../../src/examples/stakeBld.contract.js').start>} */
   const startOpts = {
     label: 'stakeBld',
     installation: stakeBld,

package/src/service.d.ts

@@ -0,0 +1,67 @@
+export const OrchestrationI: import("@endo/patterns").InterfaceGuard<{
+    makeAccount: import("@endo/patterns").MethodGuard;
+    provideICQConnection: import("@endo/patterns").MethodGuard;
+}>;
+export function prepareOrchestrationTools(zone: Zone): {
+    makeOrchestrationKit: (initialPowers?: Partial<OrchestrationPowers> | undefined) => import("@endo/exo").GuardedKit<{
+        self: {
+            allocateICAControllerPort(): Promise<any>;
+            allocateICQControllerPort(): Promise<any>;
+        };
+        public: {
+            /**
+             * @param {IBCConnectionID} hostConnectionId
+             *   the counterparty connection_id
+             * @param {IBCConnectionID} controllerConnectionId
+             *   self connection_id
+             * @returns {Promise<IcaAccount>}
+             */
+            makeAccount(hostConnectionId: `connection-${number}`, controllerConnectionId: `connection-${number}`): Promise<IcaAccount>;
+            /**
+             * @param {IBCConnectionID} controllerConnectionId
+             * @returns {Promise<ICQConnection>}
+             */
+            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").Base64Any<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
+            }>>;
+        };
+    }>;
+};
+export type OrchestrationPowers = {
+    portAllocator: globalThis.ERef<import("@endo/exo").Guarded<{
+        allocateCustomIBCPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
+        allocateICAControllerPort(): import("@agoric/vow").Vow<any>;
+        allocateICQControllerPort(): import("@agoric/vow").Vow<any>;
+        allocateCustomLocalPort(specifiedName?: string): import("@agoric/vow").Vow<any>;
+    }>>;
+};
+/**
+ * PowerStore is used so additional powers can be added on upgrade. See
+ * [#7337](https://github.com/Agoric/agoric-sdk/issues/7337) for tracking on Exo
+ * state migrations.
+ */
+export type PowerStore = MapStore<keyof OrchestrationPowers, OrchestrationPowers[keyof OrchestrationPowers]>;
+export type ICQConnectionStore = import("@endo/pass-style").RemotableObject & import("@agoric/store").MapStoreMethods<`connection-${number}`, import("@endo/exo").GuardedKit<{
+    connection: {
+        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").Base64Any<import("@agoric/cosmic-proto/tendermint/abci/types.js").ResponseQuery>[]>;
+    };
+    connectionHandler: {
+        onOpen(connection: import("@agoric/vow").Remote<import("@agoric/network").Connection>, localAddr: `/ibc-port/${string}`, remoteAddr: `/${string}ibc-port/${string}/ordered/${string}` | `/${string}ibc-port/${string}/unordered/${string}`): Promise<void>;
+        onClose(_connection: any, reason: any): Promise<void>;
+        onReceive(connection: any, bytes: any): Promise<string>;
+    };
+}>>;
+export type OrchestrationState = {
+    powers: PowerStore;
+    icqConnections: ICQConnectionStore;
+};
+export type OrchestrationTools = ReturnType<typeof prepareOrchestrationTools>;
+export type OrchestrationKit = ReturnType<OrchestrationTools["makeOrchestrationKit"]>;
+export type OrchestrationService = OrchestrationKit["public"];
+import type { Zone } from '@agoric/base-zone';
+import type { IcaAccount } from './types.js';
+//# sourceMappingURL=service.d.ts.map

package/src/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["service.js"],"names":[],"mappings":"AAsDA;;;GAOG;AA4GI;;;;;;;YAzDC;;;;;;eAMG;;YAkBH;;;eAGG;;;;;;;;EAwCV;;;;;;;;;;;;;;yBAjJY,QAAQ,CACpB,MAAU,mBAAmB,EAC7B,mBAAuB,CAAC,MAAM,mBAAmB,CAAC,CAC/C;;;;;;;;;;;;;iCA0BU;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,cAAc,EAAE,kBAAkB,CAAA;CAAE;iCAuH1D,UAAU,CAAC,OAAO,yBAAyB,CAAC;+BAC5C,UAAU,CAAC,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;mCACtD,gBAAgB,CAAC,QAAQ,CAAC;0BAxKf,mBAAmB;gCAGoB,YAAY"}

package/src/service.js

@@ -1,4 +1,3 @@
-// @ts-check
 /** @file Orchestration service */
 
 // XXX ambient types runtime imports until https://github.com/Agoric/agoric-sdk/issues/6512
@@ -18,7 +17,7 @@ import {
  * @import { Zone } from '@agoric/base-zone';
  * @import { Port, PortAllocator } from '@agoric/network';
  * @import { IBCConnectionID } from '@agoric/vats';
- * @import { ICQConnection, ChainAccount, ICQConnectionKit } from './types.js';
+ * @import { ICQConnection, IcaAccount, ICQConnectionKit } from './types.js';
  */
 
 const { Fail, bare } = assert;
@@ -116,7 +115,7 @@ const prepareOrchestrationKit = (
          *   the counterparty connection_id
          * @param {IBCConnectionID} controllerConnectionId
          *   self connection_id
-         * @returns {Promise<ChainAccount>}
+         * @returns {Promise<IcaAccount>}
          */
         async makeAccount(hostConnectionId, controllerConnectionId) {
           const port = await this.facets.self.allocateICAControllerPort();

package/src/typeGuards.d.ts

@@ -0,0 +1,28 @@
+export const ConnectionHandlerI: import("@endo/patterns").InterfaceGuard<{
+    onOpen: import("@endo/patterns").MethodGuard;
+    onClose: import("@endo/patterns").MethodGuard;
+    onReceive: import("@endo/patterns").MethodGuard;
+}>;
+export namespace ChainAddressShape {
+    let address: import("@endo/patterns").Matcher;
+    let chainId: import("@endo/patterns").Matcher;
+    let addressEncoding: import("@endo/patterns").Matcher;
+}
+export namespace Proto3Shape {
+    let typeUrl: import("@endo/patterns").Matcher;
+    let value: import("@endo/patterns").Matcher;
+}
+export namespace CoinShape {
+    let value_1: import("@endo/patterns").Matcher;
+    export { value_1 as value };
+    export let denom: import("@endo/patterns").Matcher;
+}
+export namespace ChainAmountShape {
+    let denom_1: import("@endo/patterns").Matcher;
+    export { denom_1 as denom };
+    let value_2: import("@endo/patterns").Matcher;
+    export { value_2 as value };
+}
+export const AmountArgShape: import("@endo/patterns").Matcher;
+export const DelegationShape: import("@endo/patterns").Matcher;
+//# sourceMappingURL=typeGuards.d.ts.map

package/src/typeGuards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeGuards.d.ts","sourceRoot":"","sources":["typeGuards.js"],"names":[],"mappings":"AAIA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;AAiBH,8DAAkE;AAElE,+DAA0C"}