@agoric/orchestration 0.2.0-upgrade-18-dev-aaebae4.0 → 0.2.0-upgrade-18-dev-bd8fd54.0

package/src/cosmos-api.ts

@@ -8,6 +8,7 @@ import type {
 } from '@agoric/cosmic-proto/cosmos/staking/v1beta1/staking.js';
 import type { TxBody } from '@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js';
 import type { MsgTransfer } from '@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js';
+import type { FungibleTokenPacketData } from '@agoric/cosmic-proto/ibc/applications/transfer/v2/packet.js';
 import type {
   State as IBCChannelState,
   Order,
@@ -19,7 +20,12 @@ import type {
 } from '@agoric/cosmic-proto/tendermint/abci/types.js';
 import type { Brand, Purse, Payment, Amount } from '@agoric/ertp/src/types.js';
 import type { Port } from '@agoric/network';
-import type { IBCChannelID, IBCConnectionID } from '@agoric/vats';
+import type {
+  IBCChannelID,
+  IBCConnectionID,
+  IBCPortID,
+  VTransferIBCEvent,
+} from '@agoric/vats';
 import type {
   TargetApp,
   TargetRegistration,
@@ -29,7 +35,9 @@ import type {
   RemoteIbcAddress,
 } from '@agoric/vats/tools/ibc-utils.js';
 import type { QueryDelegationTotalRewardsResponse } from '@agoric/cosmic-proto/cosmos/distribution/v1beta1/query.js';
+import type { Coin } from '@agoric/cosmic-proto/cosmos/base/v1beta1/coin.js';
 import type { AmountArg, ChainAddress, Denom, DenomAmount } from './types.js';
+import { PFM_RECEIVER } from './exos/chain-hub.js';
 
 /** An address for a validator on some blockchain, e.g., cosmos, eth, etc. */
 export type CosmosValidatorAddress = ChainAddress & {
@@ -85,12 +93,18 @@ export interface CosmosAssetInfo extends Record<string, unknown> {
  * Info for a Cosmos-based chain.
  */
 export type CosmosChainInfo = Readonly<{
+  /** can be used to lookup chainInfo (chainId) from an address value */
+  bech32Prefix?: string;
   chainId: string;
 
   connections?: Record<string, IBCConnectionInfo>; // chainId or wellKnownName
   // UNTIL https://github.com/Agoric/agoric-sdk/issues/9326
   icqEnabled?: boolean;
-
+  /**
+   * Note: developers must provide this value themselves for `.transfer` to work
+   * as expected. Please see examples for details.
+   */
+  pfmEnabled?: boolean;
   /**
    * cf https://github.com/cosmos/chain-registry/blob/master/chain.schema.json#L117
    */
@@ -224,20 +238,10 @@ export interface StakingAccountActions {
 }
 
 /**
- * Low level object that supports queries and operations for an account on a remote chain.
+ * Low level methods from IcaAccount that we pass through to CosmosOrchestrationAccount
  */
-export interface IcaAccount {
-  /**
-   * @returns the address of the account on the remote chain
-   */
-  getAddress: () => ChainAddress;
 
-  /**
-   * Submit a transaction on behalf of the remote account for execution on the remote chain.
-   * @param msgs - records for the transaction
-   * @returns acknowledgement string
-   */
-  executeTx: (msgs: TypedJson[]) => Promise<string>;
+export interface IcaAccountMethods {
   /**
    * Submit a transaction on behalf of the remote account for execution on the remote chain.
    * @param msgs - records for the transaction
@@ -265,6 +269,23 @@ export interface IcaAccount {
    * @throws {Error} if connection is currently active
    */
   reactivate: () => Promise<void>;
+}
+
+/**
+ * Low level object that supports queries and operations for an account on a remote chain.
+ */
+export interface IcaAccount extends IcaAccountMethods {
+  /**
+   * @returns the address of the account on the remote chain
+   */
+  getAddress: () => ChainAddress;
+
+  /**
+   * Submit a transaction on behalf of the remote account for execution on the remote chain.
+   * @param msgs - records for the transaction
+   * @returns acknowledgement string
+   */
+  executeTx: (msgs: TypedJson[]) => Promise<string>;
   /** @returns the address of the remote channel */
   getRemoteAddress: () => RemoteIbcAddress;
   /** @returns the address of the local channel */
@@ -278,16 +299,22 @@ export interface LiquidStakingMethods {
   liquidStake: (amount: AmountArg) => Promise<void>;
 }
 
+// TODO support StakingAccountQueries
 /** Methods supported only on Agoric chain accounts */
-export interface LocalAccountMethods {
+export interface LocalAccountMethods extends StakingAccountActions {
   /** deposit payment (from zoe, for example) to the account */
-  deposit: (payment: Payment<'nat'>) => Promise<void>;
+  deposit: (payment: Payment<'nat'>) => Promise<Amount<'nat'>>;
   /** withdraw a Payment from the account */
   withdraw: (amount: Amount<'nat'>) => Promise<Payment<'nat'>>;
   /**
    * Register a handler that receives an event each time ICS-20 transfers are
-   * sent or received by the underlying account. Each account may be associated
-   * with at most one handler at a given time.
+   * sent or received by the underlying account.
+   *
+   * Handler includes {@link VTransferIBCEvent} and
+   * {@link FungibleTokenPacketData} that can be used for application logic.
+   *
+   * Each account may be associated with at most one handler at a given time.
+   *
    * Does not grant the handler the ability to intercept a transfer. For a
    * blocking handler, aka 'IBC Hooks', leverage `registerActiveTap` from
    * `transferMiddleware` directly.
@@ -306,6 +333,12 @@ export interface IBCMsgTransferOptions {
   timeoutHeight?: MsgTransfer['timeoutHeight'];
   timeoutTimestamp?: MsgTransfer['timeoutTimestamp'];
   memo?: string;
+  forwardOpts?: {
+    /** The recipient address for the intermediate transfer. Defaults to 'pfm' unless specified */
+    intermediateRecipient?: ChainAddress;
+    timeout?: ForwardInfo['forward']['timeout'];
+    retries?: ForwardInfo['forward']['retries'];
+  };
 }
 
 /**
@@ -318,17 +351,71 @@ export interface IBCMsgTransferOptions {
  * @see {OrchestrationAccountI}
  */
 export type CosmosChainAccountMethods<CCI extends CosmosChainInfo> =
-  (CCI extends {
-    icaEnabled: true;
-  }
-    ? IcaAccount
-    : {}) &
-    CCI extends {
-    stakingTokens: {};
-  }
-    ? StakingAccountActions & StakingAccountQueries
-    : {};
+  IcaAccountMethods &
+    (CCI extends {
+      stakingTokens: {};
+    }
+      ? StakingAccountActions & StakingAccountQueries
+      : {});
 
 export type ICQQueryFunction = (
   msgs: JsonSafe<RequestQuery>[],
 ) => Promise<JsonSafe<ResponseQuery>[]>;
+
+/**
+ * Message structure for PFM memo
+ *
+ * @see {@link https://github.com/cosmos/chain-registry/blob/58b603bbe01f70e911e3ad2bdb6b90c4ca665735/_memo_keys/ICS20_memo_keys.json#L38-L60}
+ */
+export interface ForwardInfo {
+  forward: {
+    receiver: ChainAddress['value'];
+    port: IBCPortID;
+    channel: IBCChannelID;
+    /** e.g. '10m' */
+    timeout: GoDuration;
+    /** default is 3? */
+    retries: number;
+    next?: {
+      forward: ForwardInfo;
+    };
+  };
+}
+
+/**
+ * Object used to help build MsgTransfer parameters for IBC transfers.
+ *
+ * If `forwardInfo` is present:
+ * - it must be stringified and provided as the `memo` field value for
+ * use with `MsgTransfer`.
+ * - `receiver` will be set to `"pfm"` - purposely invalid bech32. see {@link https://github.com/cosmos/ibc-apps/blob/26f3ad8f58e4ffc7769c6766cb42b954181dc100/middleware/packet-forward-middleware/README.md#minimal-example---chain-forward-a-b-c}
+ */
+export type TransferRoute = {
+  /** typically, `transfer` */
+  sourcePort: string;
+  sourceChannel: IBCChannelID;
+  token: Coin;
+} & (
+  | {
+      receiver: typeof PFM_RECEIVER | ChainAddress['value'];
+      /** contains PFM forwarding info */
+      forwardInfo: ForwardInfo;
+    }
+  | {
+      receiver: string;
+      forwardInfo?: never;
+    }
+);
+
+/** Single units allowed in Go time duration strings */
+type GoDurationUnit = 'h' | 'm' | 's' | 'ms' | 'us' | 'ns';
+
+/**
+ * Type for a time duration string in Go (cosmos-sdk). For example, "1h", "3m".
+ *
+ * Note: this does not support composite values like "1h30m", "1m30s",
+ * which are allowed in Go.
+ *
+ * @see https://pkg.go.dev/time#ParseDuration
+ */
+export type GoDuration = `${number}${GoDurationUnit}`;

package/src/examples/auto-stake-it.contract.d.ts

@@ -1,5 +1,18 @@
 export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: OrchestrationPowers & {
     marshaller: Marshaller;
+    chainInfo?: Record<string, Readonly<{
+        bech32Prefix?: string;
+        chainId: string;
+        connections?: Record<string, import("../cosmos-api.js").IBCConnectionInfo>;
+        icqEnabled?: boolean;
+        pfmEnabled?: boolean;
+        stakingTokens?: Readonly<Array<{
+            denom: string;
+        }>>;
+    }>>;
+    assetInfo?: [Denom, DenomDetail & {
+        brandKey?: string;
+    }][];
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
         makeAccountsInvitation(): Promise<Invitation<import("@agoric/vow").Vow<import("@agoric/vow").Vow<{
@@ -7,7 +20,7 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
                 [k: string]: import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>;
             };
             invitationMakers: import("@endo/exo").Guarded<{
-                Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA | undefined): Promise<Invitation<unknown, IA>>;
+                Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA): Promise<Invitation<unknown, IA>>;
             }>;
         }>>, {
             chainName: string;
@@ -16,16 +29,20 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
     }>;
     creatorFacet: import("@endo/exo").Guarded<{
         registerChain(chainName: string, chainInfo: Readonly<{
+            bech32Prefix?: string;
             chainId: string;
             connections?: Record<string, import("../cosmos-api.js").IBCConnectionInfo>;
             icqEnabled?: boolean;
+            pfmEnabled?: boolean;
             stakingTokens?: Readonly<Array<{
                 denom: string;
             }>>;
         }>, connectionInfo: import("../cosmos-api.js").IBCConnectionInfo): Promise<void>;
-        registerAsset(denom: import("../orchestration-api.js").Denom, detail: import("../types.js").DenomDetail): Promise<void>;
+        registerAsset(denom: Denom, detail: DenomDetail): Promise<void>;
     }>;
 }>;
 export type AutoStakeItSF = typeof start;
 import type { OrchestrationPowers } from '../utils/start-helper.js';
+import type { Denom } from '../types.js';
+import type { DenomDetail } from '../types.js';
 //# sourceMappingURL=auto-stake-it.contract.d.ts.map

package/src/examples/auto-stake-it.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-stake-it.contract.d.ts","sourceRoot":"","sources":["auto-stake-it.contract.js"],"names":[],"mappings":"AAwEA;gBAhDiB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDsB;4BAGnC,OAAO,KAAK;yCA9DgC,0BAA0B"}
+{"version":3,"file":"auto-stake-it.contract.d.ts","sourceRoot":"","sources":["auto-stake-it.contract.js"],"names":[],"mappings":"AAmFA;gBAzDiB,UAAU;;;;;;;;;;;gBAEV,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDd;4BAGnC,OAAO,KAAK;yCAxEgC,0BAA0B;2BAC9B,aAAa;iCAAb,aAAa"}

package/src/examples/auto-stake-it.contract.js

@@ -8,10 +8,12 @@ import { preparePortfolioHolder } from '../exos/portfolio-holder-kit.js';
 import { withOrchestration } from '../utils/start-helper.js';
 import { prepareStakingTap } from './auto-stake-it-tap-kit.js';
 import * as flows from './auto-stake-it.flows.js';
+import { registerChainsAndAssets } from '../utils/chain-hub-helper.js';
 
 /**
  * @import {Zone} from '@agoric/zone';
  * @import {OrchestrationPowers, OrchestrationTools} from '../utils/start-helper.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '../types.js';
  */
 
 /**
@@ -23,13 +25,15 @@ import * as flows from './auto-stake-it.flows.js';
  * @param {ZCF} zcf
  * @param {OrchestrationPowers & {
  *   marshaller: Marshaller;
- * }} _privateArgs
+ *   chainInfo?: Record<string, CosmosChainInfo>;
+ *   assetInfo?: [Denom, DenomDetail & { brandKey?: string }][];
+ * }} privateArgs
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
  */
 const contract = async (
   zcf,
-  _privateArgs,
+  privateArgs,
   zone,
   { chainHub, orchestrateAll, vowTools },
 ) => {
@@ -67,6 +71,13 @@ const contract = async (
 
   const creatorFacet = prepareChainHubAdmin(zone, chainHub);
 
+  registerChainsAndAssets(
+    chainHub,
+    zcf.getTerms().brands,
+    privateArgs.chainInfo,
+    privateArgs.assetInfo,
+  );
+
   return { publicFacet, creatorFacet };
 };
 

package/src/examples/auto-stake-it.flows.d.ts

@@ -10,7 +10,7 @@ export function makeAccounts(orch: Orchestrator, { makeStakingTap, makePortfolio
         [k: string]: ResolvedPublicTopic<unknown>;
     };
     invitationMakers: import("@endo/exo").Guarded<{
-        Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA | undefined): Promise<Invitation<unknown, IA>>;
+        Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA): Promise<Invitation<unknown, IA>>;
     }>;
 }>>;
 import type { Orchestrator } from '@agoric/orchestration';

package/src/examples/basic-flows.contract.d.ts

@@ -1,5 +1,18 @@
 export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: OrchestrationPowers & {
     marshaller: Marshaller;
+    chainInfo?: Record<string, Readonly<{
+        bech32Prefix?: string;
+        chainId: string;
+        connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
+        icqEnabled?: boolean;
+        pfmEnabled?: boolean;
+        stakingTokens?: Readonly<Array<{
+            denom: string;
+        }>>;
+    }>>;
+    assetInfo?: [Denom, DenomDetail & {
+        brandKey?: string;
+    }][];
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
         makeOrchAccountInvitation(): Promise<Invitation<import("@agoric/vow").Vow<import("../utils/zoe-tools.js").ResolvedContinuingOfferResult>, {
@@ -10,7 +23,7 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
                 [k: string]: import("@agoric/zoe/src/contractSupport/topics.js").ResolvedPublicTopic<unknown>;
             };
             invitationMakers: import("@endo/exo").Guarded<{
-                Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA | undefined): Promise<Invitation<unknown, IA>>;
+                Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA): Promise<Invitation<unknown, IA>>;
             }>;
         }>>, {
             chainNames: string[];
@@ -19,4 +32,6 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
 }>;
 export type BasicFlowsSF = typeof start;
 import type { OrchestrationPowers } from '../utils/start-helper.js';
+import type { Denom } from '@agoric/orchestration';
+import type { DenomDetail } from '@agoric/orchestration';
 //# sourceMappingURL=basic-flows.contract.d.ts.map

package/src/examples/basic-flows.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basic-flows.contract.d.ts","sourceRoot":"","sources":["basic-flows.contract.js"],"names":[],"mappings":"AA6DA;gBA3CiB,UAAU;;;;;;;;;;;;;;;;;GA2CsB;2BAGnC,OAAO,KAAK;yCApDgC,0BAA0B"}
+{"version":3,"file":"basic-flows.contract.d.ts","sourceRoot":"","sources":["basic-flows.contract.js"],"names":[],"mappings":"AAwEA;gBApDiB,UAAU;;;;;;;;;;;gBAEV,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE;;;;;;;;;;;;;;;;;GAkDd;2BAGnC,OAAO,KAAK;yCA7DgC,0BAA0B;2BAD9B,uBAAuB;iCAAvB,uBAAuB"}

package/src/examples/basic-flows.contract.js

@@ -6,10 +6,12 @@ import { InvitationShape } from '@agoric/zoe/src/typeGuards.js';
 import { M } from '@endo/patterns';
 import { preparePortfolioHolder } from '../exos/portfolio-holder-kit.js';
 import { withOrchestration } from '../utils/start-helper.js';
+import { registerChainsAndAssets } from '../utils/chain-hub-helper.js';
 import * as flows from './basic-flows.flows.js';
 
 /**
  * @import {Zone} from '@agoric/zone';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
  * @import {OrchestrationPowers, OrchestrationTools} from '../utils/start-helper.js';
  */
 
@@ -17,15 +19,17 @@ import * as flows from './basic-flows.flows.js';
  * @param {ZCF} zcf
  * @param {OrchestrationPowers & {
  *   marshaller: Marshaller;
- * }} _privateArgs
+ *   chainInfo?: Record<string, CosmosChainInfo>;
+ *   assetInfo?: [Denom, DenomDetail & { brandKey?: string }][];
+ * }} privateArgs
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
  */
 const contract = async (
   zcf,
-  _privateArgs,
+  privateArgs,
   zone,
-  { orchestrateAll, vowTools },
+  { chainHub, orchestrateAll, vowTools },
 ) => {
   const makePortfolioHolder = preparePortfolioHolder(
     zone.subZone('portfolio'),
@@ -56,6 +60,13 @@ const contract = async (
     },
   );
 
+  registerChainsAndAssets(
+    chainHub,
+    zcf.getTerms().brands,
+    privateArgs.chainInfo,
+    privateArgs.assetInfo,
+  );
+
   return { publicFacet };
 };
 

package/src/examples/basic-flows.flows.d.ts

@@ -10,7 +10,7 @@ export function makePortfolioAccount(orch: Orchestrator, { makePortfolioHolder }
         [k: string]: ResolvedPublicTopic<unknown>;
     };
     invitationMakers: import("@endo/exo").Guarded<{
-        Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA | undefined): Promise<Invitation<unknown, IA>>;
+        Proxying<IA extends unknown[]>(chainName: string, action: string, invitationArgs?: IA): Promise<Invitation<unknown, IA>>;
     }>;
 }>>;
 import type { Orchestrator } from '@agoric/orchestration';

package/src/examples/send-anywhere.contract.d.ts

@@ -2,10 +2,15 @@
  * @import {Vow} from '@agoric/vow';
  * @import {Zone} from '@agoric/zone';
  * @import {OrchestrationPowers, OrchestrationTools} from '../utils/start-helper.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
  */
 export const SingleNatAmountRecord: import("@endo/patterns").Matcher;
 export function contract(zcf: ZCF, privateArgs: OrchestrationPowers & {
     marshaller: Marshaller;
+    chainInfo?: Record<string, CosmosChainInfo>;
+    assetInfo?: [Denom, DenomDetail & {
+        brandKey?: string;
+    }][];
 }, zone: Zone, { chainHub, orchestrateAll, vowTools, zoeTools }: OrchestrationTools): Promise<{
     publicFacet: import("@endo/exo").Guarded<{
         makeSendInvitation(): Promise<Invitation<Vow<void>, {
@@ -14,12 +19,25 @@ export function contract(zcf: ZCF, privateArgs: OrchestrationPowers & {
         }>>;
     }>;
     creatorFacet: import("@endo/exo").Guarded<{
-        registerChain(chainName: string, chainInfo: import("../cosmos-api.js").CosmosChainInfo, connectionInfo: import("../cosmos-api.js").IBCConnectionInfo): Promise<void>;
-        registerAsset(denom: import("../orchestration-api.js").Denom, detail: import("../types.js").DenomDetail): Promise<void>;
+        registerChain(chainName: string, chainInfo: CosmosChainInfo, connectionInfo: import("@agoric/orchestration").IBCConnectionInfo): Promise<void>;
+        registerAsset(denom: Denom, detail: DenomDetail): Promise<void>;
     }>;
 }>;
 export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: OrchestrationPowers & {
     marshaller: Marshaller;
+    chainInfo?: Record<string, Readonly<{
+        bech32Prefix?: string;
+        chainId: string;
+        connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
+        icqEnabled?: boolean;
+        pfmEnabled?: boolean;
+        stakingTokens?: Readonly<Array<{
+            denom: string;
+        }>>;
+    }>>;
+    assetInfo?: [Denom, DenomDetail & {
+        brandKey?: string;
+    }][];
 }, baggage: import("@agoric/vat-data").Baggage) => Promise<{
     publicFacet: import("@endo/exo").Guarded<{
         makeSendInvitation(): Promise<Invitation<Vow<void>, {
@@ -29,17 +47,22 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
     }>;
     creatorFacet: import("@endo/exo").Guarded<{
         registerChain(chainName: string, chainInfo: Readonly<{
+            bech32Prefix?: string;
             chainId: string;
-            connections?: Record<string, import("../cosmos-api.js").IBCConnectionInfo>;
+            connections?: Record<string, import("@agoric/orchestration").IBCConnectionInfo>;
             icqEnabled?: boolean;
+            pfmEnabled?: boolean;
             stakingTokens?: Readonly<Array<{
                 denom: string;
             }>>;
-        }>, connectionInfo: import("../cosmos-api.js").IBCConnectionInfo): Promise<void>;
-        registerAsset(denom: import("../orchestration-api.js").Denom, detail: import("../types.js").DenomDetail): Promise<void>;
+        }>, connectionInfo: import("@agoric/orchestration").IBCConnectionInfo): Promise<void>;
+        registerAsset(denom: Denom, detail: DenomDetail): Promise<void>;
     }>;
 }>;
 import type { OrchestrationPowers } from '../utils/start-helper.js';
+import type { CosmosChainInfo } from '@agoric/orchestration';
+import type { Denom } from '@agoric/orchestration';
+import type { DenomDetail } from '@agoric/orchestration';
 import type { Zone } from '@agoric/zone';
 import type { OrchestrationTools } from '../utils/start-helper.js';
 import type { Vow } from '@agoric/vow';

package/src/examples/send-anywhere.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"send-anywhere.contract.d.ts","sourceRoot":"","sources":["send-anywhere.contract.js"],"names":[],"mappings":"AASA;;;;GAIG;AAEH,qEAKE;AAaK,8BAPI,GAAG,eACH,mBAAmB,GAAG;IAC5B,UAAU,EAAE,UAAU,CAAC;CACxB,QACO,IAAI,oDACJ,kBAAkB;;;;;;;;;;;GAsD5B;AAGD;gBA5DiB,UAAU;;;;;;;;;;;;;;;;;;;GA4DsB;yCA5ES,0BAA0B;0BAD7D,cAAc;wCACqB,0BAA0B;yBAF9D,aAAa"}
+{"version":3,"file":"send-anywhere.contract.d.ts","sourceRoot":"","sources":["send-anywhere.contract.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AAEH,qEAKE;AAeK,8BATI,GAAG,eACH,mBAAmB,GAAG;IAC5B,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;CAC5D,QACO,IAAI,oDACJ,kBAAkB;;;;;;;;;;;GA6D5B;AAGD;gBArEiB,UAAU;;;;;;;;;;;gBAEV,CAAC,KAAK,EAAE,WAAW,GAAG;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE;;;;;;;;;;;;;;;;;;;;;GAmEd;yCAtFS,0BAA0B;qCAC9B,uBAAuB;2BAAvB,uBAAuB;iCAAvB,uBAAuB;0BAFtD,cAAc;wCACqB,0BAA0B;yBAF9D,aAAa"}

package/src/examples/send-anywhere.contract.js

@@ -4,6 +4,7 @@ import { M } from '@endo/patterns';
 import { prepareChainHubAdmin } from '../exos/chain-hub-admin.js';
 import { AnyNatAmountShape } from '../typeGuards.js';
 import { withOrchestration } from '../utils/start-helper.js';
+import { registerChainsAndAssets } from '../utils/chain-hub-helper.js';
 import * as flows from './send-anywhere.flows.js';
 import * as sharedFlows from './shared.flows.js';
 
@@ -11,6 +12,7 @@ import * as sharedFlows from './shared.flows.js';
  * @import {Vow} from '@agoric/vow';
  * @import {Zone} from '@agoric/zone';
  * @import {OrchestrationPowers, OrchestrationTools} from '../utils/start-helper.js';
+ * @import {CosmosChainInfo, Denom, DenomDetail} from '@agoric/orchestration';
  */
 
 export const SingleNatAmountRecord = M.and(
@@ -27,6 +29,8 @@ harden(SingleNatAmountRecord);
  * @param {ZCF} zcf
  * @param {OrchestrationPowers & {
  *   marshaller: Marshaller;
+ *   chainInfo?: Record<string, CosmosChainInfo>;
+ *   assetInfo?: [Denom, DenomDetail & { brandKey?: string }][];
  * }} privateArgs
  * @param {Zone} zone
  * @param {OrchestrationTools} tools
@@ -82,6 +86,13 @@ export const contract = async (
     },
   );
 
+  registerChainsAndAssets(
+    chainHub,
+    zcf.getTerms().brands,
+    privateArgs.chainInfo,
+    privateArgs.assetInfo,
+  );
+
   return { publicFacet, creatorFacet };
 };
 harden(contract);

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

@@ -17,7 +17,7 @@ export function start(zcf: ZCF, privateArgs: {
             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<void>;
+            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">>;
             executeTx(messages: {
                 '@type': string;
@@ -27,7 +27,7 @@ export function start(zcf: ZCF, privateArgs: {
             getAddress(): import("../orchestration-api.js").ChainAddress;
             send(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg): import("@agoric/vow").Vow<void>;
             sendAll(toAccount: import("../orchestration-api.js").ChainAddress, amounts: import("../orchestration-api.js").AmountArg[]): import("@agoric/vow").Vow<void>;
-            transfer(destination: import("../orchestration-api.js").ChainAddress, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions | undefined): import("@agoric/vow").Vow<any>;
+            transfer(destination: import("../orchestration-api.js").ChainAddress, amount: import("../orchestration-api.js").AmountArg, opts?: import("../cosmos-api.js").IBCMsgTransferOptions): import("@agoric/vow").Vow<any>;
             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<globalThis.Pattern>): import("@agoric/async-flow").HostInterface<import("@agoric/vow").Vow<{

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

@@ -105,6 +105,11 @@ export function start(zcf: ZCF<StakeIcaTerms>, privateArgs: {
             }[]>;
             getReward(validator: import("../cosmos-api.js").CosmosValidatorAddress): import("@agoric/vow").Vow<import("../orchestration-api.js").DenomAmount[]>;
             getRewards(): import("@agoric/vow").Vow<import("@agoric/async-flow").HostInterface<import("../cosmos-api.js").CosmosRewardsResponse>>;
+            executeEncodedTx(msgs: {
+                $typeUrl?: "/google.protobuf.Any" | string | undefined;
+                typeUrl: string;
+                value: string;
+            }[], opts?: Partial<Omit<import("@agoric/cosmic-proto/cosmos/tx/v1beta1/tx.js").TxBody, "messages">> | undefined): import("@agoric/vow").Vow<string>;
         }>>;
         makeAccountInvitationMaker(): Promise<Invitation<ResolvedContinuingOfferResult, undefined>>;
     }>;

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

@@ -1 +1 @@
-{"version":3,"file":"stake-ica.contract.d.ts","sourceRoot":"","sources":["stake-ica.contract.js"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAelC;AAEH;;;;;;cAAsD;AAuB/C,2BAVI,GAAG,CAAC,aAAa,CAAC,eAClB;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;CACrB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGjB;4BA1HY;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,eAAe,CAAC;IAClC,sBAAsB,EAAE,eAAe,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;yBAwHU,OAAO,KAAK;6BAxJiB,cAAc;4BADhC,kBAAkB;6CAIwB,aAAa;kCAFjD,cAAc;6BAHnB,kBAAkB;mDAII,uBAAuB;qCAF5B,cAAc"}
+{"version":3,"file":"stake-ica.contract.d.ts","sourceRoot":"","sources":["stake-ica.contract.js"],"names":[],"mappings":"AAgBA;;;;;;;GAOG;AAEH,yCAAyC;AACzC,mBADW,YAAY,CAAC,OAAO,KAAK,CAAC,CAelC;AAEH;;;;;;cAAsD;AAuB/C,2BAVI,GAAG,CAAC,aAAa,CAAC,eAClB;IACN,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;IAC7B,uBAAuB,EAAE,uBAAuB,CAAC;IACjD,WAAW,EAAE,WAAW,CAAC;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,KAAK,EAAE,YAAY,CAAC;CACrB,WACO,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGjB;4BA1HY;IACR,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,eAAe,CAAC;IAClC,sBAAsB,EAAE,eAAe,CAAC;IACxC,UAAU,EAAE,OAAO,CAAC;CACrB;yBAwHU,OAAO,KAAK;6BAxJiB,cAAc;4BADhC,kBAAkB;6CAIwB,aAAa;kCAFjD,cAAc;6BAHnB,kBAAkB;mDAII,uBAAuB;qCAF5B,cAAc"}

package/src/examples/staking-combinations.contract.d.ts

@@ -8,9 +8,11 @@ export const start: (zcf: ZCF<Record<string, unknown>>, privateArgs: Orchestrati
     }>;
     creatorFacet: import("@endo/exo").Guarded<{
         registerChain(chainName: string, chainInfo: Readonly<{
+            bech32Prefix?: string;
             chainId: string;
             connections?: Record<string, import("../cosmos-api.js").IBCConnectionInfo>;
             icqEnabled?: boolean;
+            pfmEnabled?: boolean;
             stakingTokens?: Readonly<Array<{
                 denom: string;
             }>>;

package/src/examples/staking-combinations.contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"staking-combinations.contract.d.ts","sourceRoot":"","sources":["staking-combinations.contract.js"],"names":[],"mappings":"AAkKA;gBA7HiB,UAAU;;;;;;;;;;;;;;;;;;GA6HsB;yCA9IS,0BAA0B"}
+{"version":3,"file":"staking-combinations.contract.d.ts","sourceRoot":"","sources":["staking-combinations.contract.js"],"names":[],"mappings":"AAiKA;gBA5HiB,UAAU;;;;;;;;;;;;;;;;;;;;GA4HsB;yCA7IS,0BAA0B"}

package/src/examples/staking-combinations.contract.js

@@ -75,7 +75,6 @@ const contract = async (
            * @param {{ validator: CosmosValidatorAddress }} offerArgs
            */
           (seat, { validator }) =>
-            // eslint-disable-next-line no-use-before-define -- defined by orchestrateAll, necessarily after this
             orchFns.depositAndDelegate(account, seat, validator),
           'Deposit and delegate',
           undefined,
@@ -98,7 +97,6 @@ const contract = async (
 
         return zcf.makeInvitation(
           () =>
-            // eslint-disable-next-line no-use-before-define -- defined by orchestrateAll, necessarily after this
             orchFns.undelegateAndTransfer(account, {
               delegations,
               destination,
@@ -133,6 +131,7 @@ const contract = async (
   );
 
   const orchFns = orchestrateAll(flows, {
+    chainHub,
     sharedLocalAccountP,
     makeCombineInvitationMakers,
     makeExtraInvitationMaker,

package/src/examples/staking-combinations.flows.d.ts

@@ -4,7 +4,8 @@ export function makeAccount(orch: Orchestrator, ctx: {
 }, _seat: ZCFSeat, { chainName }: {
     chainName: string;
 }): Promise<ResolvedContinuingOfferResult>;
-export function depositAndDelegate(orch: Orchestrator, { sharedLocalAccountP, zoeTools }: {
+export function depositAndDelegate(orch: Orchestrator, { chainHub, sharedLocalAccountP, zoeTools }: {
+    chainHub: GuestInterface<ChainHub>;
     sharedLocalAccountP: Promise<GuestInterface<LocalOrchestrationAccountKit["holder"]>>;
     zoeTools: GuestInterface<ZoeTools>;
 }, account: GuestInterface<CosmosOrchestrationAccount>, seat: ZCFSeat, validator: CosmosValidatorAddress): Promise<void>;
@@ -19,8 +20,9 @@ import type { Orchestrator } from '../types.js';
 import type { MakeCombineInvitationMakers } from '../exos/combine-invitation-makers.js';
 import type { InvitationMakers } from '@agoric/smart-wallet/src/types.js';
 import type { ResolvedContinuingOfferResult } from '../utils/zoe-tools.js';
-import type { LocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
+import type { ChainHub } from '../types.js';
 import type { GuestInterface } from '@agoric/async-flow';
+import type { LocalOrchestrationAccountKit } from '../exos/local-orchestration-account.js';
 import type { ZoeTools } from '../utils/zoe-tools.js';
 import type { CosmosOrchestrationAccount } from '../exos/cosmos-orchestration-account.js';
 import type { CosmosValidatorAddress } from '../types.js';