@agoric/orchestration 0.2.0 → 0.2.1-upgrade-23-dev-bd79330.0.bd79330

package/src/examples/stake-bld.contract.d.ts

@@ -1,56 +1,237 @@
 export function start(zcf: ZCF, privateArgs: {
     agoricNames: Remote<NameHub>;
     localchain: Remote<LocalChain>;
-    marshaller: Marshaller;
-    storageNode: StorageNode;
+    marshaller: Remote<Marshaller>;
+    storageNode: Remote<StorageNode>;
     timerService: TimerService;
-}, baggage: import("@agoric/vat-data").Baggage): Promise<{
+}, baggage: Baggage): Promise<{
     publicFacet: import("@endo/exo").Guarded<{
         /**
          * Invitation to make an account, initialized with the give's BLD
          */
-        makeStakeBldInvitation(): Promise<globalThis.Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
+        makeStakeBldInvitation(): Promise<import("@agoric/zoe").Invitation<import("@agoric/vow").Vow<{
+            invitationMakers: {
+                [x: string]: (...args: any[]) => import("@agoric/vow").Vow<import("@endo/marshal").RemotableObject & {
+                    getAllegedBrand: () => import("@agoric/ertp").Brand<"set">;
+                } & {
+                    readonly "Symbol(tag)": {
+                        "Set-like value type": import("@agoric/zoe").InvitationDetails;
+                    };
+                }>;
+            };
+            publicSubscribers: {
+                [x: string]: {
+                    description?: string | undefined;
+                    subscriber: {
+                        getUpdateSince: (updateCount?: number | bigint | undefined) => import("@agoric/vow").Vow<{
+                            value: any;
+                            updateCount?: bigint | undefined | undefined;
+                        }>;
+                        subscribeAfter: (publishCount?: bigint | undefined) => import("@agoric/vow").Vow<{
+                            head: {
+                                done: true;
+                                value: any;
+                            } | {
+                                done?: false | undefined;
+                                value: any;
+                            };
+                            publishCount: bigint;
+                            tail: {
+                                "Symbol(passStyle)": "tagged";
+                                [Symbol.toStringTag]: "Vow";
+                                payload: import("@agoric/vow").VowPayload</*elided*/ any>;
+                            };
+                        }>;
+                    } | {};
+                    storagePath: string;
+                };
+            };
+        }>, undefined>>;
         makeAccount(): Promise<import("@endo/exo").Guarded<{
-            asContinuingOffer(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>;
-            getBalance(denom: import("../orchestration-api.js").DenomArg): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount>;
-            getBalances(): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
-            getPublicTopics(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<Record<string, import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>>>>;
-            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<import("@agoric/ertp").NatAmount>;
-            withdraw(amount: import("@agoric/ertp").NatAmount): import("@agoric/vow").Vow<globalThis.Payment<"nat">>;
+            makeProgressTracker(): import("../utils/progress.js").ProgressTracker;
+            asContinuingOffer(): import("@agoric/vow").Vow<{
+                invitationMakers: {
+                    [x: string]: (...args: any[]) => import("@agoric/vow").Vow<import("@endo/marshal").RemotableObject & {
+                        getAllegedBrand: () => import("@agoric/ertp").Brand<"set">;
+                    } & {
+                        readonly "Symbol(tag)": {
+                            "Set-like value type": import("@agoric/zoe").InvitationDetails;
+                        };
+                    }>;
+                };
+                publicSubscribers: {
+                    [x: string]: {
+                        description?: string | undefined;
+                        subscriber: {
+                            getUpdateSince: (updateCount?: number | bigint | undefined) => import("@agoric/vow").Vow<{
+                                value: any;
+                                updateCount?: bigint | undefined | undefined;
+                            }>;
+                            subscribeAfter: (publishCount?: bigint | undefined) => import("@agoric/vow").Vow<{
+                                head: {
+                                    done: true;
+                                    value: any;
+                                } | {
+                                    done?: false | undefined;
+                                    value: any;
+                                };
+                                publishCount: bigint;
+                                tail: {
+                                    "Symbol(passStyle)": "tagged";
+                                    [Symbol.toStringTag]: "Vow";
+                                    payload: import("@agoric/vow").VowPayload</*elided*/ any>;
+                                };
+                            }>;
+                        } | {};
+                        storagePath: string;
+                    };
+                };
+            }>;
+            getBalance(denom: import("../orchestration-api.js").DenomArg, opts?: import("../orchestration-api.js").QuerierOptions | undefined): import("@agoric/vow").Vow<{
+                denom: import("../orchestration-api.js").Denom;
+                value: bigint;
+            }>;
+            getBalances(opts?: import("../orchestration-api.js").QuerierOptions | undefined): import("@agoric/vow").Vow<{
+                denom: import("../orchestration-api.js").Denom;
+                value: bigint;
+            }[]>;
+            getPublicTopics(): import("@agoric/vow").Vow<{
+                [x: string]: {
+                    description?: string | undefined;
+                    subscriber: {
+                        getUpdateSince: (updateCount?: number | bigint | undefined) => import("@agoric/vow").Vow<{
+                            value: {};
+                            updateCount?: bigint | undefined | undefined;
+                        }>;
+                        subscribeAfter: (publishCount?: bigint | undefined) => import("@agoric/vow").Vow<{
+                            head: {
+                                done: true;
+                                value: any;
+                            } | {
+                                done?: false | undefined;
+                                value: {};
+                            };
+                            publishCount: bigint;
+                            tail: {
+                                "Symbol(passStyle)": "tagged";
+                                [Symbol.toStringTag]: "Vow";
+                                payload: import("@agoric/vow").VowPayload</*elided*/ any>;
+                            };
+                        }>;
+                    } | {};
+                    storagePath: string;
+                };
+            }>;
+            delegate(validatorAddress: string, ertpAmount: import("@agoric/ertp").Amount<"nat">): import("@agoric/vow").Vow<Record<PropertyKey, unknown>>;
+            undelegate(validatorAddress: string, ertpAmount: import("@agoric/ertp").Amount<"nat">): import("@agoric/vow").Vow<void | import("@agoric/time").TimestampRecord>;
+            deposit(payment: Payment<"nat">): import("@agoric/vow").Vow<{
+                brand: {
+                    "Symbol(passStyle)": "remotable";
+                    [Symbol.toStringTag]: string;
+                    isMyIssuer: (allegedIssuer: import("jessie.js").ERef<import("@agoric/ertp").Issuer<"nat", import("@endo/patterns").Key>>) => Promise<boolean>;
+                    getAllegedName: () => string;
+                    getDisplayInfo: () => import("@agoric/ertp").DisplayInfo<"nat">;
+                    getAmountShape: () => import("@endo/patterns").Pattern;
+                };
+                value: bigint;
+            }>;
+            withdraw(amount: import("@agoric/ertp").NatAmount): import("@agoric/vow").Vow<Payment<"nat">>;
             executeTx(messages: {
                 '@type': string;
             }[]): import("@agoric/vow").Vow<{
                 '@type': string;
             }[]>;
             getAddress(): import("../orchestration-api.js").CosmosChainAddress;
-            send(toAccount: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
-            sendAll(toAccount: import("../orchestration-api.js").CosmosChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
-            transfer(destination: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions): import("@agoric/vow").Vow<any>;
+            send(toAccount: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg, opts?: import("../orchestration-api.js").ActionOptions | undefined): import("@agoric/vow").Vow<{}>;
+            sendAll(toAccount: import("../orchestration-api.js").CosmosChainAddress, amounts: import("../orchestration-api.js").AmountArg[], opts?: import("../orchestration-api.js").ActionOptions | undefined): import("@agoric/vow").Vow<{}>;
+            transfer(destination: import("../orchestration-api.js").AccountIdArg, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<{}>;
             parseInboundTransfer(packet: Record<string, any>): import("@agoric/vow").Vow<{
-                amount: import("../orchestration-api.js").DenomAmount;
+                amount: {
+                    denom: import("../orchestration-api.js").Denom;
+                    value: bigint;
+                };
                 fromAccount: string;
                 toAccount: string;
-                extra: Record<string, any>;
+                extra: {
+                    [x: string]: any;
+                };
+            }>;
+            transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<{}>;
+            sendThenWaitForAck(packetSender: Remote<import("../exos/packet-tools.js").PacketSender>, opts?: import("../exos/packet-tools.js").PacketOptions | undefined): import("@agoric/vow").Vow<string>;
+            matchFirstPacket(args_0?: import("@agoric/vow").EVow<import("@endo/patterns").Pattern>): import("@agoric/vow").Vow<{
+                resolver: {
+                    resolve: (value?: any) => void;
+                    reject: (reason?: any) => void;
+                };
+                match: {
+                    "Symbol(passStyle)": "tagged";
+                    [Symbol.toStringTag]: "Vow";
+                    payload: import("@agoric/vow").VowPayload<any>;
+                };
+            }>;
+            monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").Vow<{
+                /**
+                 * performs unregistration (and sends the
+                 * corresponding "BRIDGE_TARGET_UNREGISTER" message to the targetHost).
+                 */
+                revoke: () => import("@agoric/vow").Vow<void>;
+                /**
+                 *   replaces the app associated with the target (but with no corresponding
+                 *   message).
+                 */
+                updateTargetApp: (targetApp: import("jessie.js").ERef<import("@agoric/vats/src/bridge-target.js").TargetApp>) => import("@agoric/vow").Vow<void>;
             }>;
-            transferSteps(amount: import("../orchestration-api.js").AmountArg, msg: import("../orchestration-api.js").TransferMsg): import("@agoric/vow").Vow<void>;
-            sendThenWaitForAck(packetSender: Remote<import("../exos/packet-tools.js").PacketSender>, opts?: import("../exos/packet-tools.js").PacketOptions | undefined): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<any>>;
-            matchFirstPacket(args_0?: import("@agoric/vow").EVow<Pattern>): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<{
-                resolver: import("@agoric/vow").VowResolver<any>;
-                match: import("@agoric/vow").Vow<any>;
-            }>>;
-            monitorTransfers(tap: import("@agoric/vats/src/bridge-target.js").TargetApp): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("@agoric/vats/src/bridge-target.js").TargetRegistration>>;
         }>>;
         /**
          * Invitation to make an account, without any funds
          */
-        makeAccountInvitationMaker(): Promise<globalThis.Invitation<import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>>, undefined>>;
+        makeAccountInvitationMaker(): Promise<import("@agoric/zoe").Invitation<import("@agoric/vow").Vow<{
+            invitationMakers: {
+                [x: string]: (...args: any[]) => import("@agoric/vow").Vow<import("@endo/marshal").RemotableObject & {
+                    getAllegedBrand: () => import("@agoric/ertp").Brand<"set">;
+                } & {
+                    readonly "Symbol(tag)": {
+                        "Set-like value type": import("@agoric/zoe").InvitationDetails;
+                    };
+                }>;
+            };
+            publicSubscribers: {
+                [x: string]: {
+                    description?: string | undefined;
+                    subscriber: {
+                        getUpdateSince: (updateCount?: number | bigint | undefined) => import("@agoric/vow").Vow<{
+                            value: any;
+                            updateCount?: bigint | undefined | undefined;
+                        }>;
+                        subscribeAfter: (publishCount?: bigint | undefined) => import("@agoric/vow").Vow<{
+                            head: {
+                                done: true;
+                                value: any;
+                            } | {
+                                done?: false | undefined;
+                                value: any;
+                            };
+                            publishCount: bigint;
+                            tail: {
+                                "Symbol(passStyle)": "tagged";
+                                [Symbol.toStringTag]: "Vow";
+                                payload: import("@agoric/vow").VowPayload</*elided*/ any>;
+                            };
+                        }>;
+                    } | {};
+                    storagePath: string;
+                };
+            };
+        }>, undefined>>;
     }>;
 }>;
 import type { ZCF } from '@agoric/zoe';
 import type { NameHub } from '@agoric/vats';
 import type { Remote } from '@agoric/internal';
 import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
 import type { TimerService } from '@agoric/time';
+import type { Baggage } from '@agoric/vat-data';
+import type { Payment } from '@agoric/ertp';
 //# sourceMappingURL=stake-bld.contract.d.ts.map

package/src/examples/stake-bld.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stake-bld.contract.d.ts","sourceRoot":"","sources":["stake-bld.contract.js"],"names":[],"mappings":"AAqCO,2BAVI,GAAG,eACH;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO,kBAAkB,EAAE,OAAO;;QAsEvC;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6BH;;WAEG;;;GAaR;yBAlIqB,aAAa;6BAJT,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;kCAD9B,cAAc"}
+{"version":3,"file":"stake-bld.contract.d.ts","sourceRoot":"","sources":["stake-bld.contract.js"],"names":[],"mappings":"AA2CO,2BAVI,GAAG,eACH;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,WAAW,EAAE,OAAO,WAAW,CAAC,CAAC;IACjC,YAAY,EAAE,YAAY,CAAC;CAC5B,WACO,OAAO;;QA+EZ;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA6BH;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAaR;yBA/IqB,aAAa;6BAJT,cAAc;4BACf,kBAAkB;gCAEd,gCAAgC;gCAIhC,0CAA0C;iCACzC,0CAA0C;kCANzC,cAAc;6BAGnB,kBAAkB;6BAClB,cAAc"}

package/src/examples/stake-bld.contract.js

@@ -2,6 +2,7 @@
  * @file Stake BLD contract
  */
 import { makeTracer } from '@agoric/internal';
+import { wrapRemoteMarshaller } from '@agoric/internal/src/marshal/wrap-marshaller.js';
 import { heapVowE as E, prepareVowTools } from '@agoric/vow/vat.js';
 import { prepareRecorderKitMakers } from '@agoric/zoe/src/contractSupport/recorder.js';
 import { withdrawFromSeat } from '@agoric/zoe/src/contractSupport/zoeHelpers.js';
@@ -13,6 +14,7 @@ import { makeChainHub } from '../exos/chain-hub.js';
 import { prepareLocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
 import fetchedChainInfo from '../fetched-chain-info.js';
 import { makeZoeTools } from '../utils/zoe-tools.js';
+import { prepareProgressTracker } from '../utils/progress.js';
 
 /**
  * @import {NameHub} from '@agoric/vats';
@@ -20,6 +22,10 @@ import { makeZoeTools } from '../utils/zoe-tools.js';
  * @import {TimerService} from '@agoric/time';
  * @import {LocalChain} from '@agoric/vats/src/localchain.js';
  * @import {ZCF} from '@agoric/zoe';
+ * @import {Baggage} from '@agoric/vat-data';
+ * @import {Payment} from '@agoric/ertp';
+ * @import {Marshaller} from '@agoric/internal/src/lib-chainStorage.js';
+ * @import {StorageNode} from '@agoric/internal/src/lib-chainStorage.js';
  */
 
 const trace = makeTracer('StakeBld');
@@ -29,20 +35,28 @@ const trace = makeTracer('StakeBld');
  * @param {{
  *   agoricNames: Remote<NameHub>;
  *   localchain: Remote<LocalChain>;
- *   marshaller: Marshaller;
- *   storageNode: StorageNode;
+ *   marshaller: Remote<Marshaller>;
+ *   storageNode: Remote<StorageNode>;
  *   timerService: TimerService;
  * }} privateArgs
- * @param {import('@agoric/vat-data').Baggage} baggage
+ * @param {Baggage} baggage
  */
 export const start = async (zcf, privateArgs, baggage) => {
   const zone = makeDurableZone(baggage);
 
+  const { marshaller: remoteMarshaller } = privateArgs;
+  //  withOrchestration() provides this but this contract shows how to use orchestration without that
+  const cachingMarshaller = wrapRemoteMarshaller(remoteMarshaller);
+
   const { makeRecorderKit } = prepareRecorderKitMakers(
     baggage,
-    privateArgs.marshaller,
+    cachingMarshaller,
   );
   const vowTools = prepareVowTools(zone.subZone('vows'));
+  const makeProgressTracker = await prepareProgressTracker(
+    zone.subZone('orchestration'),
+    { vowTools },
+  );
 
   const chainHub = makeChainHub(
     zone.subZone('chainHub'),
@@ -55,6 +69,7 @@ export const start = async (zcf, privateArgs, baggage) => {
   const makeLocalOrchestrationAccountKit = prepareLocalOrchestrationAccountKit(
     zone,
     {
+      makeProgressTracker,
       makeRecorderKit,
       zcf,
       timerService,