@agoric/orchestration 0.3.0-u23.0 → 0.3.0-u23.1

package/src/utils/permit2/signatureTransferHelpers.d.ts

@@ -0,0 +1,334 @@
+/**
+ * @file Helpers for working with Uniswap Permit2 SignatureTransfer
+ * `permitWitnessTransferFrom`.
+ * @see {@link https://docs.uniswap.org/contracts/permit2/reference/signature-transfer}
+ *
+ * This is original code that was adapted for permit2-sdk, unlike @see ./permit2SignatureTransfer.ts
+ */
+import type { AbiParameterToPrimitiveType, TypedData } from 'abitype';
+import type { TypedDataParameter } from '../abitype.js';
+import type { encodeType } from '../viem-utils/hashTypedData.js';
+declare const PrimaryTypes: import("@agoric/internal/src/keyMirror.js").KeyMirrorResult<{
+    PermitBatchWitnessTransferFrom: null;
+    PermitWitnessTransferFrom: null;
+}>;
+type PrimaryTypeName = keyof typeof PrimaryTypes;
+export declare const isPermit2MessageType: (type: string) => type is PrimaryTypeName;
+declare const permit2BaseTypeParams: {
+    PermitBatchWitnessTransferFrom: [{
+        readonly name: "permitted";
+        readonly type: "TokenPermissions[]";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+    PermitWitnessTransferFrom: [{
+        readonly name: "permitted";
+        readonly type: "TokenPermissions";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+};
+/**
+ * Make a function for returning the `witnessTypeString` argument to use in a
+ * `permitWitnessTransferFrom` call.
+ */
+export declare const makeWitnessTypeStringExtractor: (powers: {
+    encodeType: typeof encodeType;
+}) => (types: TypedData) => string;
+/**
+ * Confirm that the input is a EIP-712 `types` record with a single struct
+ * definition for the first argument to a `permitWitnessTransferFrom` call
+ * (i.e., named either "PermitWitnessTransferFrom" for a single-token transfer
+ * or "PermitBatchWitnessTransferFrom" for a multi-token transfer), and return
+ * the TypedDataParameter describing the witness field of that definition.
+ */
+export declare const extractWitnessFieldFromTypes: <T extends Readonly<TypedDataParameter>>(types: { [K in PrimaryTypeName]: Record<K, readonly [...(typeof permit2BaseTypeParams)[K], T]>; }[PrimaryTypeName]) => T;
+export declare const TokenPermissionsComponents: [{
+    readonly name: "token";
+    readonly type: "address";
+}, {
+    readonly name: "amount";
+    readonly type: "uint256";
+}];
+export declare const TokenPermissionsInternalTypeName: "struct ISignatureTransfer.TokenPermissions";
+export declare const PermitTransferFromComponents: [{
+    readonly name: "permitted";
+    readonly type: "tuple";
+    readonly internalType: "struct ISignatureTransfer.TokenPermissions";
+    readonly components: [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "nonce";
+    readonly type: "uint256";
+}, {
+    readonly name: "deadline";
+    readonly type: "uint256";
+}];
+export declare const PermitTransferFromInternalTypeName: "struct ISignatureTransfer.PermitTransferFrom";
+export type PermitTransferFromStruct = AbiParameterToPrimitiveType<{
+    type: 'tuple';
+    internalType: typeof PermitTransferFromInternalTypeName;
+    components: typeof PermitTransferFromComponents;
+}>;
+export declare const PermitBatchTransferFromComponents: [{
+    readonly name: "permitted";
+    readonly type: "tuple[]";
+    readonly internalType: "struct ISignatureTransfer.TokenPermissions[]";
+    readonly components: [{
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "nonce";
+    readonly type: "uint256";
+}, {
+    readonly name: "deadline";
+    readonly type: "uint256";
+}];
+export declare const PermitBatchTransferFromInternalTypeName: "struct ISignatureTransfer.PermitBatchTransferFrom";
+export type PermitBatchTransferFromStruct = AbiParameterToPrimitiveType<{
+    type: 'tuple';
+    internalType: typeof PermitBatchTransferFromInternalTypeName;
+    components: typeof PermitBatchTransferFromComponents;
+}>;
+export declare const SignatureTransferDetailsComponents: [{
+    readonly name: "to";
+    readonly type: "address";
+}, {
+    readonly name: "requestedAmount";
+    readonly type: "uint256";
+}];
+export declare const SignatureTransferDetailsInternalTypeName: "struct ISignatureTransfer.SignatureTransferDetails";
+export type SignatureTransferDetailsStruct = AbiParameterToPrimitiveType<{
+    type: 'tuple';
+    internalType: typeof SignatureTransferDetailsInternalTypeName;
+    components: typeof SignatureTransferDetailsComponents;
+}>;
+export declare const PermitWitnessTransferFromInputComponents: [{
+    readonly name: "permit";
+    readonly type: "tuple";
+    readonly internalType: "struct ISignatureTransfer.PermitTransferFrom";
+    readonly components: [{
+        readonly name: "permitted";
+        readonly type: "tuple";
+        readonly internalType: "struct ISignatureTransfer.TokenPermissions";
+        readonly components: [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "transferDetails";
+    readonly type: "tuple";
+    readonly internalType: "struct ISignatureTransfer.SignatureTransferDetails";
+    readonly components: [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "requestedAmount";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "owner";
+    readonly type: "address";
+}, {
+    readonly name: "witness";
+    readonly type: "bytes32";
+}, {
+    readonly name: "witnessTypeString";
+    readonly type: "string";
+}, {
+    readonly name: "signature";
+    readonly type: "bytes";
+}];
+export type PermitWitnessTransferFromPayload = AbiParameterToPrimitiveType<{
+    type: 'tuple';
+    components: typeof PermitWitnessTransferFromInputComponents;
+}>;
+export declare const BatchPermitWitnessTransferFromInputComponents: [{
+    readonly name: "permit";
+    readonly type: "tuple";
+    readonly internalType: "struct ISignatureTransfer.PermitBatchTransferFrom";
+    readonly components: [{
+        readonly name: "permitted";
+        readonly type: "tuple[]";
+        readonly internalType: "struct ISignatureTransfer.TokenPermissions[]";
+        readonly components: [{
+            readonly name: "token";
+            readonly type: "address";
+        }, {
+            readonly name: "amount";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "transferDetails";
+    readonly type: "tuple[]";
+    readonly internalType: "struct ISignatureTransfer.SignatureTransferDetails[]";
+    readonly components: [{
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly name: "requestedAmount";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "owner";
+    readonly type: "address";
+}, {
+    readonly name: "witness";
+    readonly type: "bytes32";
+}, {
+    readonly name: "witnessTypeString";
+    readonly type: "string";
+}, {
+    readonly name: "signature";
+    readonly type: "bytes";
+}];
+export type BatchPermitWitnessTransferFromPayload = AbiParameterToPrimitiveType<{
+    type: 'tuple';
+    components: typeof BatchPermitWitnessTransferFromInputComponents;
+}>;
+export declare const PermitWitnessTransferFromFunctionABIType: {
+    readonly name: "permitWitnessTransferFrom";
+    readonly inputs: [{
+        readonly name: "permit";
+        readonly type: "tuple";
+        readonly internalType: "struct ISignatureTransfer.PermitTransferFrom";
+        readonly components: [{
+            readonly name: "permitted";
+            readonly type: "tuple";
+            readonly internalType: "struct ISignatureTransfer.TokenPermissions";
+            readonly components: [{
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+            }];
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "transferDetails";
+        readonly type: "tuple";
+        readonly internalType: "struct ISignatureTransfer.SignatureTransferDetails";
+        readonly components: [{
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly name: "requestedAmount";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "witness";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "witnessTypeString";
+        readonly type: "string";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+};
+export declare const BatchPermitWitnessTransferFunctionABIType: {
+    readonly name: "permitWitnessTransferFrom";
+    readonly inputs: [{
+        readonly name: "permit";
+        readonly type: "tuple";
+        readonly internalType: "struct ISignatureTransfer.PermitBatchTransferFrom";
+        readonly components: [{
+            readonly name: "permitted";
+            readonly type: "tuple[]";
+            readonly internalType: "struct ISignatureTransfer.TokenPermissions[]";
+            readonly components: [{
+                readonly name: "token";
+                readonly type: "address";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+            }];
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "transferDetails";
+        readonly type: "tuple[]";
+        readonly internalType: "struct ISignatureTransfer.SignatureTransferDetails[]";
+        readonly components: [{
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly name: "requestedAmount";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "witness";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "witnessTypeString";
+        readonly type: "string";
+    }, {
+        readonly name: "signature";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+};
+export {};
+//# sourceMappingURL=signatureTransferHelpers.d.ts.map

package/src/utils/permit2/signatureTransferHelpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signatureTransferHelpers.d.ts","sourceRoot":"","sources":["signatureTransferHelpers.ts"],"names":[],"mappings":"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"}

package/src/utils/permit2.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file entry point for orchestration's permit2 utils
+ *
+ * This file should eventually become a `.js` file once we can strip types from
+ * `.ts` files and rewrite relative import specifiers in `.js` files.
+ *
+ * NPM consumers could use jsr.io to consume this in the meantime.
+ */
+export * from './permit2/signatureTransfer.js';
+export * from './permit2/signatureTransferHelpers.js';
+//# sourceMappingURL=permit2.d.ts.map

package/src/utils/permit2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permit2.d.ts","sourceRoot":"","sources":["permit2.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC"}

package/src/utils/progress.d.ts

@@ -0,0 +1,41 @@
+export namespace progressTrackerAsyncFlowUtils {
+    function promiseFromVow<T>(specimen: T): Promise<Fulfilled<T>>;
+    function reduceProgressReports<A = unknown>(tracker: ProgressTracker, reducer: PublicationReducer<ProgressReport, A>, initialAccum: A): Promise<A>;
+}
+export function prepareProgressTracker(zone: Zone, { vowTools: { makeVowKit } }: {
+    vowTools: Pick<VowTools, "makeVowKit">;
+}): () => import("@endo/exo").Guarded<{
+    getCurrentProgressReport(): ProgressReport;
+    /**
+     * @param {ProgressReport} progressReport
+     */
+    update(progressReport: ProgressReport): ProgressReport;
+    finish(): ProgressReport;
+    /**
+     * CAVEAT: Intended for use only by `progress.js` utilities.
+     *
+     * @returns {PublicationInternals<ProgressReport>}
+     * @internal
+     */
+    exposePublicationInternals(): PublicationInternals<ProgressReport>;
+}>;
+export type ProgressReport = Record<string, any>;
+export type PublicationInternals<T> = {
+    value: T;
+    tail: EVow<PublicationInternals<T>>;
+};
+/**
+ * Called on the value of each linked T. This
+ *   function should perform any side-effects it can when it receives a new
+ *   value, since there is no guarantee that the ProgressRecord tail will be
+ *   prompt (it may take a long time with cross-chain communication) or ever
+ *   fulfill (it may result in a rejection).
+ */
+export type PublicationReducer<T, A = unknown> = (value: T | undefined | null, accum: A) => EVow<A | null>;
+export type MakeProgressTracker = ReturnType<typeof prepareProgressTracker>;
+export type ProgressTracker = ReturnType<MakeProgressTracker>;
+import type { Fulfilled } from '@agoric/vow';
+import type { Zone } from '@agoric/base-zone';
+import type { VowTools } from '@agoric/vow';
+import type { EVow } from '@agoric/vow';
+//# sourceMappingURL=progress.d.ts.map

package/src/utils/progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress.d.ts","sourceRoot":"","sources":["progress.js"],"names":[],"mappings":";IAgDkB,wBAJH,CAAC,YACH,CAAC,GACC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAQjC;IAcsB,+BATT,CAAC,qBACJ,eAAe,WACf,kBAAkB,CAAC,cAAc,EAAE,CAAC,CAAC,gBACrC,CAAC,GAIC,OAAO,CAAC,CAAC,CAAC,CA0BtB;;AAYI,6CAJI,IAAI,gCAEZ;IAA6C,QAAQ,EAA7C,IAAI,CAAC,QAAQ,EAAE,YAAY,CAAC;CACtC;;IA0BO;;OAEG;2BADQ,cAAc;;IAyBzB;;;;;OAKG;kCAFU,oBAAoB,CAAC,cAAc,CAAC;GAYxD;6BA9JY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;iCAInB,CAAC;WAEA,CAAC;UACD,KAAK,oBAAoB,CAAC,CAAC,CAAC,CAAC;;;;;;;;;+BAI9B,CAAC,EACA,CAAC,sBAMJ,CAAC,GAAG,SAAS,GAAG,IAAI,SAEpB,CAAC,KACC,KAAK,CAAC,GAAG,IAAI,CAAC;kCA6Id,UAAU,CAAC,OAAO,sBAAsB,CAAC;8BAIzC,UAAU,CAAC,mBAAmB,CAAC;+BA3KA,aAAa;0BAClC,mBAAmB;8BADE,aAAa;0BAAb,aAAa"}

package/src/utils/registry.d.ts

@@ -0,0 +1,6 @@
+export function convertChainInfo(registry: Pick<ChainRegistryClient, "chains" | "ibcData">): Promise<{
+    [k: string]: CosmosChainInfo;
+}>;
+import type { ChainRegistryClient } from '@chain-registry/client';
+import type { CosmosChainInfo } from '../cosmos-api.js';
+//# sourceMappingURL=registry.d.ts.map

package/src/utils/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["registry.js"],"names":[],"mappings":"AAqFO,2CAFI,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,SAAS,CAAC;;GAgDzD;yCAzHqC,wBAAwB;qCAC5B,kBAAkB"}

package/src/utils/start-helper.d.ts

@@ -0,0 +1,129 @@
+export function provideOrchestration(zcf: ZCF, baggage: Baggage, remotePowers: OrchestrationPowers, remoteMarshaller: Remote<Marshaller>, opts?: {
+    chainInfoValueShape?: WithOrchestrationOpts["chainInfoValueShape"];
+}): {
+    makeOrchestrateKit: (zone: Zone) => {
+        orchestrate: <HC, GF extends import("../orchestration-api.js").OrchestrationFlow<import("@agoric/async-flow").GuestInterface<HC>>>(durableName: string, hostCtx: HC, guestFn: GF) => HostForGuest<GF>;
+        orchestrateAll: <HC extends Record<string, any>, GFM extends {
+            [durableName: string]: import("../orchestration-api.js").OrchestrationFlow<import("@agoric/async-flow").GuestInterface<HC>>;
+        }>(guestFns: GFM, hostCtx: HC) => { [N in keyof GFM]: HostForGuest<GFM[N]>; };
+    };
+    baggage: Baggage;
+    cachingMarshaller: {
+        serialize: (val?: import("@endo/pass-style").Passable) => import("@agoric/vow").ERef<import("@endo/marshal").CapData<unknown>>;
+        unserialize: (data: import("@endo/marshal").CapData<unknown>) => any;
+        toCapData: (val?: import("@endo/pass-style").Passable) => import("@agoric/vow").ERef<import("@endo/marshal").CapData<unknown>>;
+        fromCapData: (data: import("@endo/marshal").CapData<unknown>) => any;
+    } & import("@endo/pass-style").RemotableObject<`Alleged: ${string}`> & import("@endo/eventual-send").RemotableBrand<{}, {
+        serialize: (val?: import("@endo/pass-style").Passable) => import("@agoric/vow").ERef<import("@endo/marshal").CapData<unknown>>;
+        unserialize: (data: import("@endo/marshal").CapData<unknown>) => any;
+        toCapData: (val?: import("@endo/pass-style").Passable) => import("@agoric/vow").ERef<import("@endo/marshal").CapData<unknown>>;
+        fromCapData: (data: import("@endo/marshal").CapData<unknown>) => any;
+    }>;
+    chainHub: import("@endo/exo").Guarded<{
+        registerChain(name: string, chainInfo: import("../orchestration-api.js").ChainInfo): void;
+        updateChain(chainName: string, chainInfo: import("../orchestration-api.js").ChainInfo): void;
+        getChainInfo<K extends string>(chainName: K): import("@agoric/vow").Vow<ActualChainInfo<K>>;
+        getChainInfoByChainId(chainId: import("../orchestration-api.js").CaipChainId): import("../orchestration-api.js").ChainInfo;
+        registerConnection(primaryChainId: string, counterpartyChainId: string, connectionInfo: import("@agoric/network/ibc").IBCConnectionInfo): void;
+        updateConnection(primaryChainId: string, counterpartyChainId: string, connectionInfo: import("@agoric/network/ibc").IBCConnectionInfo): void;
+        getConnectionInfo(primary: string | {
+            chainId: string;
+        }, counter: string | {
+            chainId: string;
+        }): import("@agoric/vow").Vow<import("@agoric/network/ibc").IBCConnectionInfo>;
+        getChainsAndConnection<C1 extends string, C2 extends string>(primaryName: C1, counterName: C2): import("@agoric/vow").Vow<[ActualChainInfo<C1>, ActualChainInfo<C2>, import("@agoric/network/ibc").IBCConnectionInfo]>;
+        registerAsset(denom: import("../orchestration-api.js").Denom, detail: DenomDetail): void;
+        updateAsset(denom: import("../orchestration-api.js").Denom, detail: DenomDetail): void;
+        getAsset(denom: import("../orchestration-api.js").Denom, srcChainName: string): DenomDetail | undefined;
+        getDenom(brand: import("@agoric/ertp").Brand): import("../orchestration-api.js").Denom | undefined;
+        resolveAccountId(partialId: import("../orchestration-api.js").AccountId | import("../cosmos-api.js").Bech32Address): import("../orchestration-api.js").AccountId;
+        coerceCosmosAddress(partialId: import("../orchestration-api.js").AccountIdArg | import("../cosmos-api.js").Bech32Address): import("../orchestration-api.js").CosmosChainAddress;
+        makeTransferRoute(destination: import("../orchestration-api.js").AccountIdArg | import("../cosmos-api.js").Bech32Address, denomAmount: import("../orchestration-api.js").DenomAmount, srcChainName: string, forwardOpts?: import("../cosmos-api.js").IBCMsgTransferOptions["forwardOpts"]): import("../cosmos-api.js").TransferRoute;
+        isEmpty(): boolean;
+    }>;
+    vowTools: import("@agoric/vow").VowTools;
+    asyncFlowTools: {
+        prepareAsyncFlowKit: (zone: Zone, tag: string, guestAsyncFunc: import("@agoric/async-flow").GuestAsyncFunc, options?: {
+            startEager?: boolean;
+        }) => (activationArgs: any) => import("@endo/exo").GuardedKit<{
+            flow: {
+                getFlowState(): import("@agoric/async-flow").FlowState;
+                restart(eager?: boolean): void;
+                wake(): void;
+                getOutcome(): import("@agoric/vow").Vow<any>;
+                dump(): ([op: "doFulfill", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, fulfillment: import("@endo/pass-style").Passable] | [op: "doReject", vow: import("@agoric/vow").Vow<import("@endo/pass-style").Passable>, reason: import("@endo/pass-style").Passable] | [op: "doReturn", callIndex: number, result: import("@endo/pass-style").Passable] | [op: "doThrow", callIndex: number, problem: import("@endo/pass-style").Passable] | [op: "checkCall", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSendOnly", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number] | [op: "checkSend", target: import("@endo/pass-style").Passable, optVerb: PropertyKey | undefined, args: import("@endo/pass-style").Passable[], callIndex: number])[];
+                getOptFatalProblem(): any;
+            };
+            admin: {
+                reset(): void;
+                complete(): void;
+                panic(fatalProblem: any): never;
+            };
+            wakeWatcher: {
+                onFulfilled(_fulfillment: any): void;
+                onRejected(_fulfillment: any): void;
+            };
+        }>;
+        asyncFlow: <F extends import("@agoric/async-flow").GuestAsyncFunc>(zone: Zone, tag: string, guestFunc: F, options?: {
+            startEager?: boolean;
+        }) => import("@agoric/async-flow").HostOf<F>;
+        adminAsyncFlow: import("@endo/exo").Guarded<{
+            getFailures(): import("@endo/patterns").CopyMap<any, import("@endo/pass-style").Passable>;
+            wakeAll(): void;
+            getFlowForOutcomeVow(outcomeVow: any): any;
+        }>;
+        allWokenP: Promise<void>;
+        prepareEndowment: (zone: Zone, tag: string, e: unknown) => any;
+    };
+    zcfTools: {
+        assertUniqueKeyword: (keyword: string) => void;
+        atomicRearrange: (transfers: import("@agoric/zoe").TransferPart[]) => void;
+        makeInvitation: <R, A = undefined>(offerHandler: import("@agoric/zoe").OfferHandler<import("@agoric/vow").ERef<R>, A>, description: string, customDetails?: object, proposalShape?: Pattern) => import("@agoric/vow").Vow<import("@agoric/zoe").Invitation<R, A>>;
+    };
+    zoeTools: {
+        localTransfer: (srcSeat: import("@agoric/zoe").ZCFSeat, localAccount: import("../cosmos-api.js").LocalAccountMethods, amounts: import("@agoric/zoe").AmountKeywordRecord) => import("@agoric/vow").Vow<void>;
+        withdrawToSeat: (localAccount: import("../cosmos-api.js").LocalAccountMethods, destSeat: import("@agoric/zoe").ZCFSeat, amounts: import("@agoric/zoe").AmountKeywordRecord) => import("@agoric/vow").Vow<void>;
+    };
+    zone: Zone;
+    orchestrate: <HC, GF extends import("../orchestration-api.js").OrchestrationFlow<import("@agoric/async-flow").GuestInterface<HC>>>(durableName: string, hostCtx: HC, guestFn: GF) => HostForGuest<GF>;
+    orchestrateAll: <HC extends Record<string, any>, GFM extends {
+        [durableName: string]: import("../orchestration-api.js").OrchestrationFlow<import("@agoric/async-flow").GuestInterface<HC>>;
+    }>(guestFns: GFM, hostCtx: HC) => { [N in keyof GFM]: HostForGuest<GFM[N]>; };
+};
+export function withOrchestration<CT extends Record<string, unknown>, PA extends OrchestrationPowers & {
+    marshaller: Remote<Marshaller>;
+}, R>(contractFn: (zcf: ZCF<CT>, privateArgs: PA, zone: Zone, tools: OrchestrationTools) => Promise<R>, opts?: WithOrchestrationOpts): (zcf: ZCF<CT>, privateArgs: PA, baggage: Baggage) => Promise<R>;
+export type OrchestrationPowers = {
+    localchain: Remote<LocalChain>;
+    orchestrationService: Remote<CosmosInterchainService>;
+    storageNode?: Remote<StorageNode>;
+    timerService: Remote<TimerService>;
+    agoricNames: Remote<NameHub>;
+};
+export type WithOrchestrationOpts = {
+    /**
+     * - Controls whether account
+     * information (address, channel identifiers for ICAs) should be automatically
+     * published to vstorage
+     */
+    publishAccountInfo?: boolean | undefined;
+    /**
+     * - Overrides the default valueShape
+     * for ChainHub's `chainInfos: MapStore`. Intended to support a legacy version
+     * of ChainHub for FastUSDC.
+     */
+    chainInfoValueShape?: Pattern;
+};
+export type OrchestrationTools = Omit<ReturnType<typeof provideOrchestration>, "zone">;
+import type { ZCF } from '@agoric/zoe';
+import type { Baggage } from '@agoric/vat-data';
+import type { Marshaller } from '@agoric/internal/src/lib-chainStorage.js';
+import type { Remote } from '@agoric/vow';
+import type { Zone } from '@agoric/zone';
+import type { Pattern } from '@endo/patterns';
+import type { LocalChain } from '@agoric/vats/src/localchain.js';
+import type { CosmosInterchainService } from '../exos/exo-interfaces.js';
+import type { StorageNode } from '@agoric/internal/src/lib-chainStorage.js';
+import type { TimerService } from '@agoric/time';
+import type { NameHub } from '@agoric/vats';
+//# sourceMappingURL=start-helper.d.ts.map

package/src/utils/start-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"start-helper.d.ts","sourceRoot":"","sources":["start-helper.js"],"names":[],"mappings":"AAiEO,0CARI,GAAG,WACH,OAAO,gBACP,mBAAmB,oBACnB,OAAO,UAAU,CAAC,SAE1B;IAA4D,mBAAmB,GAAvE,qBAAqB,CAAC,qBAAqB,CAAC;CACpD;+BA6GU,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAnFH,CAAC;;;;;;;;;;;;;;;;;;;;;sBAyK6sV,CAAC;;;;;;;;;;;;;;;;;;;;;;;;EApD5tV;AA+BM,kCAfgC,EAAE,SAA3B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAE,EAGhC,EAAE,SAFM,mBAAmB,GAAG;IAC/B,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;CAC/B,EACQ,CAAC,cACH,CACN,GAAG,EAAE,IAAI,EAAE,CAAC,EACZ,WAAW,EAAE,EAAE,EACf,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,kBAAkB,KACtB,OAAO,CAAC,CAAC,CAAC,SACP,qBAAqB,GACnB,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,CAsBzE;kCAhOU;IACR,UAAU,EAAE,OAAO,UAAU,CAAC,CAAC;IAC/B,oBAAoB,EAAE,OAAO,uBAAuB,CAAC,CAAC;IACtD,WAAW,CAAC,EAAE,OAAO,WAAW,CAAC,CAAC;IAClC,YAAY,EAAE,OAAO,YAAY,CAAC,CAAC;IACnC,WAAW,EAAE,OAAO,OAAO,CAAC,CAAC;CAC9B;;;;;;;;;;;;;0BAQU,OAAO;;iCAmKP,IAAI,CAAC,UAAU,CAAC,OAAO,oBAAoB,CAAC,EAAE,MAAM,CAAC;yBArL7C,aAAa;6BANT,kBAAkB;gCAJF,0CAA0C;4BAM3D,aAAa;0BACf,cAAc;6BACX,gBAAgB;gCANb,gCAAgC;6CAOnB,2BAA2B;iCAT3B,0CAA0C;kCAGrD,cAAc;6BAEnB,cAAc"}

package/src/utils/time.d.ts

@@ -0,0 +1,38 @@
+/**
+ * XXX should this be durable? resumable?
+ *
+ * @param {Remote<TimerService>} timer
+ */
+export function makeTimestampHelper(timer: Remote<TimerService>): {
+    /**
+     * XXX do this need to be resumable / use Vows?
+     *
+     * Takes the current time from ChainTimerService and adds a relative time
+     * (`secondsInFuture`) to determine a timeout timestamp in nanoseconds.
+     * Useful for {@link MsgTransfer.timeoutTimestamp}.
+     *
+     * @param {bigint} [secondsInFuture] defaults to 300n (5 minutes)
+     * @returns {Promise<bigint>} Timeout timestamp in absolute nanoseconds
+     *   since unix epoch
+     */
+    getTimeoutTimestampNS(secondsInFuture?: bigint): Promise<bigint>;
+    /** @param {IBCMsgTransferOptions} [opts] */
+    vowOrValueFromOpts(opts?: IBCMsgTransferOptions): bigint | Promise<bigint> | undefined;
+};
+/**
+ * @import {TimerService} from '@agoric/time';
+ * @import {Remote} from '@agoric/internal';
+ * @import {EReturn} from '@endo/far';
+ * @import {IBCMsgTransferOptions} from '../cosmos-api.js';
+ * @import {MsgTransfer} from '@agoric/cosmic-proto/ibc/applications/transfer/v1/tx.js';
+ */
+export const SECONDS_PER_MINUTE: 60n;
+export const MILLISECONDS_PER_SECOND: 1000n;
+export const NANOSECONDS_PER_MILLISECOND: 1000000n;
+export const NANOSECONDS_PER_SECOND: 1000000000n;
+export type TimestampHelper = EReturn<typeof makeTimestampHelper>;
+import type { TimerService } from '@agoric/time';
+import type { Remote } from '@agoric/internal';
+import type { IBCMsgTransferOptions } from '../cosmos-api.js';
+import type { EReturn } from '@endo/far';
+//# sourceMappingURL=time.d.ts.map

package/src/utils/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["time.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,2CAFW,OAAO,YAAY,CAAC;IAI3B;;;;;;;;;;OAUG;4CAHQ,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC;IAc5B,4CAA4C;8BAAhC,qBAAqB;EAYpC;AAtDD;;;;;;GAMG;AAEH,iCAAkC,GAAG,CAAC;AACtC,sCAAuC,KAAK,CAAC;AAC7C,0CAA2C,QAAU,CAAC;AACtD,qCAAsC,WAAc,CAAC;8BA6CvC,QAAQ,OAAO,mBAAmB,CAAC;kCAvDlB,cAAc;4BACpB,kBAAkB;2CAEH,kBAAkB;6BADhC,WAAW"}

package/src/utils/viem-utils/hashTypedData.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @file viem internal typedData utils exported for direct usage
+ *
+ * @license MIT
+ * Copyright (c) 2023-present weth, LLC
+ * Copied from https://github.com/wevm/viem/blob/ea0b9d4c391567dd811acbfd889121bb9cb1c26c/src/utils/signature/hashTypedData.ts
+ */
+type MessageTypeProperty = {
+    name: string;
+    type: string;
+};
+/**
+ * Serialize an EIP-712 struct definition to a string per
+ * https://eips.ethereum.org/EIPS/eip-712#definition-of-encodetype
+ */
+export declare function encodeType({ primaryType, types, }: {
+    primaryType: string;
+    types: Record<string, readonly MessageTypeProperty[]>;
+}): string;
+export {};
+//# sourceMappingURL=hashTypedData.d.ts.map

package/src/utils/viem-utils/hashTypedData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashTypedData.d.ts","sourceRoot":"","sources":["hashTypedData.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,KAAK,mBAAmB,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;;GAGG;AACH,wBAAgB,UAAU,CAAC,EACzB,WAAW,EACX,KAAK,GACN,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,mBAAmB,EAAE,CAAC,CAAC;CACvD,UAaA"}

package/src/utils/viem-utils/types.d.ts

@@ -0,0 +1,6 @@
+import type { ByteArray, Hex, Signature, TypedData, TypedDataDefinition } from 'viem';
+export type WithSignature<T> = T & {
+    signature: Hex | ByteArray | Signature;
+};
+export type SignedTypedDataDefinition<typedData extends TypedData | Record<string, unknown> = TypedData, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData, primaryTypes = typedData extends TypedData ? keyof typedData : string> = WithSignature<TypedDataDefinition<typedData, primaryType, primaryTypes>>;
+//# sourceMappingURL=types.d.ts.map

package/src/utils/viem-utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,GAAG,EACH,SAAS,EACT,SAAS,EACT,mBAAmB,EACpB,MAAM,MAAM,CAAC;AAEd,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,GAAG;IACjC,SAAS,EAAE,GAAG,GAAG,SAAS,GAAG,SAAS,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,yBAAyB,CACnC,SAAS,SAAS,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACjE,WAAW,SAAS,MAAM,SAAS,GAAG,cAAc,GAAG,MAAM,SAAS,EAEtE,YAAY,GAAG,SAAS,SAAS,SAAS,GAAG,MAAM,SAAS,GAAG,MAAM,IACnE,aAAa,CAAC,mBAAmB,CAAC,SAAS,EAAE,WAAW,EAAE,YAAY,CAAC,CAAC,CAAC"}

package/src/utils/viem.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @file entry point for some common viem utils
+ *
+ * This file should eventually become a `.js` file once we can strip types from
+ * `.ts` files and rewrite relative import specifiers in `.js` files.
+ *
+ * NPM consumers could use jsr.io to consume this in the meantime.
+ */
+export * from './viem-utils/hashTypedData.js';
+export * from './viem-utils/types.js';
+//# sourceMappingURL=viem.d.ts.map

package/src/utils/viem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem.d.ts","sourceRoot":"","sources":["viem.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,+BAA+B,CAAC;AAC9C,cAAc,uBAAuB,CAAC"}