@agoric/zoe 0.26.3-dev-da3b8a8.0 → 0.26.3-dev-7710838.0

package/src/contractSupport/recorder.d.ts

@@ -1,229 +0,0 @@
-export function prepareRecorder(baggage: MapStore<string, any>, marshaller: ERef<Marshaller>): (publisher: Publisher<unknown>, storageNode: StorageNode, valueShape?: TypedMatcher<unknown> | undefined) => {
-    getStorageNode(): StorageNode;
-    /**
-     * Memoizes the remote call to the storage node
-     *
-     * @returns {Promise<string>}
-     */
-    getStoragePath(): Promise<string>;
-    /**
-     * Marshalls before writing to storage or publisher to help ensure the two streams match.
-     *
-     * @param {unknown} value
-     * @returns {Promise<void>}
-     */
-    write(value: unknown): Promise<void>;
-    /**
-     * Like `write` but prevents future writes and terminates the publisher.
-     *
-     * @param {unknown} value
-     * @returns {Promise<void>}
-     */
-    writeFinal(value: unknown): Promise<void>;
-} & import("@endo/eventual-send").RemotableBrand<{}, {
-    getStorageNode(): StorageNode;
-    /**
-     * Memoizes the remote call to the storage node
-     *
-     * @returns {Promise<string>}
-     */
-    getStoragePath(): Promise<string>;
-    /**
-     * Marshalls before writing to storage or publisher to help ensure the two streams match.
-     *
-     * @param {unknown} value
-     * @returns {Promise<void>}
-     */
-    write(value: unknown): Promise<void>;
-    /**
-     * Like `write` but prevents future writes and terminates the publisher.
-     *
-     * @param {unknown} value
-     * @returns {Promise<void>}
-     */
-    writeFinal(value: unknown): Promise<void>;
-}>;
-export function defineRecorderKit({ makeRecorder, makeDurablePublishKit }: {
-    makeRecorder: MakeRecorder;
-    makeDurablePublishKit: ReturnType<typeof prepareDurablePublishKit>;
-}): <T>(storageNode: StorageNode, valueShape?: TypedMatcher<T> | undefined) => RecorderKit<T>;
-export function defineERecorderKit({ makeRecorder, makeDurablePublishKit }: {
-    makeRecorder: MakeRecorder;
-    makeDurablePublishKit: ReturnType<typeof prepareDurablePublishKit>;
-}): <T>(storageNodeP: ERef<StorageNode>, valueShape?: TypedMatcher<T> | undefined) => EventualRecorderKit<T>;
-export function prepareRecorderKit(baggage: MapStore<string, any>, marshaller: ERef<Marshaller>): <T>(storageNode: StorageNode, valueShape?: TypedMatcher<T> | undefined) => RecorderKit<T>;
-export function prepareRecorderKitMakers(baggage: MapStore<string, any>, marshaller: ERef<Marshaller>): {
-    makeDurablePublishKit: (options?: {
-        valueDurability?: "mandatory" | undefined;
-    } | undefined) => {
-        publisher: {
-            publish(value: any): void;
-            finish(finalValue: any): void;
-            fail(reason: any): void;
-        };
-        subscriber: {
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        };
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        publisher: {
-            publish(value: any): void;
-            finish(finalValue: any): void;
-            fail(reason: any): void;
-        };
-        subscriber: {
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        };
-    }>;
-    makeRecorder: (publisher: Publisher<unknown>, storageNode: StorageNode, valueShape?: TypedMatcher<unknown> | undefined) => {
-        getStorageNode(): StorageNode;
-        /**
-         * Memoizes the remote call to the storage node
-         *
-         * @returns {Promise<string>}
-         */
-        getStoragePath(): Promise<string>;
-        /**
-         * Marshalls before writing to storage or publisher to help ensure the two streams match.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        write(value: unknown): Promise<void>;
-        /**
-         * Like `write` but prevents future writes and terminates the publisher.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        writeFinal(value: unknown): Promise<void>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getStorageNode(): StorageNode;
-        /**
-         * Memoizes the remote call to the storage node
-         *
-         * @returns {Promise<string>}
-         */
-        getStoragePath(): Promise<string>;
-        /**
-         * Marshalls before writing to storage or publisher to help ensure the two streams match.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        write(value: unknown): Promise<void>;
-        /**
-         * Like `write` but prevents future writes and terminates the publisher.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        writeFinal(value: unknown): Promise<void>;
-    }>;
-    makeRecorderKit: <T>(storageNode: StorageNode, valueShape?: TypedMatcher<T> | undefined) => RecorderKit<T>;
-    makeERecorderKit: <T_1>(storageNodeP: ERef<StorageNode>, valueShape?: TypedMatcher<T_1> | undefined) => EventualRecorderKit<T_1>;
-};
-export function prepareMockRecorderKitMakers(): {
-    storageNode: StorageNode & {
-        countSetValueCalls: () => number;
-    };
-    makeDurablePublishKit: (options?: {
-        valueDurability?: "mandatory" | undefined;
-    } | undefined) => {
-        publisher: {
-            publish(value: any): void;
-            finish(finalValue: any): void;
-            fail(reason: any): void;
-        };
-        subscriber: {
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        };
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        publisher: {
-            publish(value: any): void;
-            finish(finalValue: any): void;
-            fail(reason: any): void;
-        };
-        subscriber: {
-            subscribeAfter(publishCount?: bigint): Promise<any>;
-            getUpdateSince(updateCount: any): any;
-        };
-    }>;
-    makeRecorder: (publisher: Publisher<unknown>, storageNode: StorageNode, valueShape?: TypedMatcher<unknown> | undefined) => {
-        getStorageNode(): StorageNode;
-        /**
-         * Memoizes the remote call to the storage node
-         *
-         * @returns {Promise<string>}
-         */
-        getStoragePath(): Promise<string>;
-        /**
-         * Marshalls before writing to storage or publisher to help ensure the two streams match.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        write(value: unknown): Promise<void>;
-        /**
-         * Like `write` but prevents future writes and terminates the publisher.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        writeFinal(value: unknown): Promise<void>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getStorageNode(): StorageNode;
-        /**
-         * Memoizes the remote call to the storage node
-         *
-         * @returns {Promise<string>}
-         */
-        getStoragePath(): Promise<string>;
-        /**
-         * Marshalls before writing to storage or publisher to help ensure the two streams match.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        write(value: unknown): Promise<void>;
-        /**
-         * Like `write` but prevents future writes and terminates the publisher.
-         *
-         * @param {unknown} value
-         * @returns {Promise<void>}
-         */
-        writeFinal(value: unknown): Promise<void>;
-    }>;
-    makeRecorderKit: <T>(storageNode: StorageNode, valueShape?: TypedMatcher<T> | undefined) => RecorderKit<T>;
-    makeERecorderKit: <T_1>(storageNodeP: ERef<StorageNode>, valueShape?: TypedMatcher<T_1> | undefined) => EventualRecorderKit<T_1>;
-};
-export type Recorder<T> = {
-    getStorageNode(): StorageNode;
-    getStoragePath(): Promise<string>;
-    write(value: T): Promise<void>;
-    writeFinal(value: T): Promise<void>;
-};
-export type RecorderKit<T> = Pick<PublishKit<T>, 'subscriber'> & {
-    recorder: Recorder<T>;
-};
-export type EventualRecorderKit<T> = Pick<PublishKit<T>, 'subscriber'> & {
-    recorderP: ERef<Recorder<T>>;
-};
-export type MakeRecorder = ReturnType<typeof prepareRecorder>;
-export type MakeRecorderKit = ReturnType<typeof defineRecorderKit>;
-export type MakeERecorderKit = ReturnType<typeof defineERecorderKit>;
-/**
- * Stop-gap until https://github.com/Agoric/agoric-sdk/issues/6160
- * explictly specify the type that the Pattern will verify through a match.
- *
- * This is a Pattern but since that's `any`, including in the typedef turns the
- * whole thing to `any`.
- */
-export type TypedMatcher<T> = {
-    validatedType?: T;
-};
-export type MatchedType<TM extends TypedMatcher<any>> = TM extends TypedMatcher<infer T> ? T : never;
-import { prepareDurablePublishKit } from '@agoric/notifier';
-//# sourceMappingURL=recorder.d.ts.map

package/src/contractSupport/recorder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"recorder.d.ts","sourceRoot":"","sources":["recorder.js"],"names":[],"mappings":"AA4CO,4EAFI,KAAK,UAAU,CAAC;;IAmCrB;;;;OAIG;sBADU,QAAQ,MAAM,CAAC;IAa5B;;;;;OAKG;iBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;IAa1B;;;;;OAKG;sBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;;;IArC1B;;;;OAIG;sBADU,QAAQ,MAAM,CAAC;IAa5B;;;;;OAKG;iBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;IAa1B;;;;;OAKG;sBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;GAkB/B;AAWM,2EAFI;IAAC,YAAY,EAAE,YAAY,CAAC;IAAC,qBAAqB,EAAE,WAAW,+BAA+B,CAAC,CAAA;CAAC,oBAK9F,WAAW,8DAUvB;AAUM,4EAFI;IAAC,YAAY,EAAE,YAAY,CAAC;IAAC,qBAAqB,EAAE,WAAW,+BAA+B,CAAC,CAAA;CAAC,qBAK9F,KAAK,WAAW,CAAC,sEAY7B;AAaM,+EAFI,KAAK,UAAU,CAAC,oBA9Cd,WAAW,8DAuDvB;AAaM,qFAFI,KAAK,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;QAvIrB;;;;WAIG;0BADU,QAAQ,MAAM,CAAC;QAa5B;;;;;WAKG;qBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;QAa1B;;;;;WAKG;0BAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;;;QArC1B;;;;WAIG;0BADU,QAAQ,MAAM,CAAC;QAa5B;;;;;WAKG;qBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;QAa1B;;;;;WAKG;0BAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;;sCAgCnB,WAAW;0CAuBX,KAAK,WAAW,CAAC;EAmE7B;AAKM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QApKD;;;;WAIG;0BADU,QAAQ,MAAM,CAAC;QAa5B;;;;;WAKG;qBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;QAa1B;;;;;WAKG;0BAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;;;QArC1B;;;;WAIG;0BADU,QAAQ,MAAM,CAAC;QAa5B;;;;;WAKG;qBAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;QAa1B;;;;;WAKG;0BAFQ,OAAO,GACL,QAAQ,IAAI,CAAC;;sCAgCnB,WAAW;0CAuBX,KAAK,WAAW,CAAC;EA+E7B;;sBA/NgC,WAAW;sBAAoB,QAAQ,MAAM,CAAC;iBAAe,CAAC,GAAG,QAAQ,IAAI,CAAC;sBAAoB,CAAC,GAAG,QAAQ,IAAI,CAAC;;6BAKvI,KAAK,WAAW,CAAC,CAAC,EAAE,YAAY,CAAC,GAAG;IAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAA;CAAE;qCAK7D,KAAK,WAAW,CAAC,CAAC,EAAE,YAAY,CAAC,GAAG;IAAE,SAAS,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,CAAA;CAAE;2BAmGnE,WAAW,sBAAsB,CAAC;8BAuBlC,WAAW,wBAAwB,CAAC;+BA0BpC,WAAW,yBAAyB,CAAC;;;;;;;;8BA2EtC;IAAE,aAAa,CAAC,EAAE,CAAC,CAAA;CAAE;;yCAhQO,kBAAkB"}

package/src/contractSupport/safeMath.d.ts

@@ -1,11 +0,0 @@
-export namespace natSafeMath {
-    let add: NatOp;
-    let subtract: NatOp;
-    let multiply: NatOp;
-    let floorDivide: NatOp;
-    let ceilDivide: NatOp;
-    let bankersDivide: NatOp;
-    let isGTE: (x: number | bigint, y: number | bigint) => boolean;
-}
-export type NatOp = (x: number | bigint, y: number | bigint) => NatValue;
-//# sourceMappingURL=safeMath.d.ts.map

package/src/contractSupport/safeMath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"safeMath.d.ts","sourceRoot":"","sources":["safeMath.js"],"names":[],"mappings":";aAYa,KAAK;kBAGL,KAAK;kBAEL,KAAK;qBAEL,KAAK;oBAEL,KAAK;uBAQN,KAAK;;;wBA3BC,MAAM,GAAG,MAAM,KAAK,MAAM,GAAG,MAAM,KAAK,QAAQ"}

package/src/contractSupport/stateMachine.d.ts

@@ -1,6 +0,0 @@
-export function makeStateMachine(initialState: any, allowedTransitionsArray: any): {
-    canTransitionTo: (nextState: any) => any;
-    transitionTo: (nextState: any) => void;
-    getStatus: (_: any) => any;
-};
-//# sourceMappingURL=stateMachine.d.ts.map

package/src/contractSupport/stateMachine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"stateMachine.d.ts","sourceRoot":"","sources":["stateMachine.js"],"names":[],"mappings":"AAUA;;;;EAYC"}

package/src/contractSupport/statistics.d.ts

@@ -1,7 +0,0 @@
-export function calculateMedian<T>(samples: T[], math: TypedMath<T>): T | undefined;
-export type TypedMath<T> = {
-    add: (a: T, b: T) => T;
-    divide: (a: T, b: bigint) => T;
-    isGTE: (a: T, b: T) => boolean;
-};
-//# sourceMappingURL=statistics.d.ts.map

package/src/contractSupport/statistics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"statistics.d.ts","sourceRoot":"","sources":["statistics.js"],"names":[],"mappings":"AAgBO,oFAwBN;;aArCiB,CAAC,KAAK,CAAC,KAAK,CAAC;gBACb,CAAC,KAAK,MAAM,KAAK,CAAC;eAClB,CAAC,KAAK,CAAC,KAAK,OAAO"}

package/src/contractSupport/topics.d.ts

@@ -1,22 +0,0 @@
-export { SubscriberShape };
-export const PublicTopicShape: import("@endo/patterns").Matcher;
-/**
- * @template {object} T topic value
- * @typedef {{
- *   description?: string,
- *   subscriber: Subscriber<T>,
- *   storagePath: ERef<string>,
- * }} PublicTopic
- */
-export const TopicsRecordShape: import("@endo/patterns").Matcher;
-export function makeRecorderTopic<T>(description: string, recorderKit: import("./recorder.js").RecorderKit<T> | import("./recorder.js").EventualRecorderKit<T>): PublicTopic<T>;
-export type PublicTopic<T extends unknown> = {
-    description?: string;
-    subscriber: Subscriber<T>;
-    storagePath: ERef<string>;
-};
-export type TopicsRecord = {
-    [topicName: string]: PublicTopic<unknown>;
-};
-import { SubscriberShape } from '@agoric/notifier';
-//# sourceMappingURL=topics.d.ts.map

package/src/contractSupport/topics.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"topics.d.ts","sourceRoot":"","sources":["topics.js"],"names":[],"mappings":";AAMA,gEAME;AAEF;;;;;;;GAOG;AAEH,iEAA0E;AAcnE,kDAJI,MAAM,wHAYhB;6CA7BY;IACZ,WAAe,CAAC,EAAE,MAAM,CAAC;IACzB,UAAc,EAAE,WAAW,CAAC,CAAC,CAAC;IAC9B,WAAe,EAAE,KAAK,MAAM,CAAC,CAAC;CAC3B;;;;gCApB4B,kBAAkB"}

package/src/contractSupport/types.d.ts

@@ -1,63 +0,0 @@
-type SeatGainsLossesRecord = {
-    seat: ZCFSeat;
-    /**
-     * - what the seat will
-     * gain as a result of this trade
-     */
-    gains: AmountKeywordRecord;
-    /**
-     * - what the seat [will]
-     * give up as a result of this trade. Losses is optional, but can
-     * only be omitted if the keywords for both seats are the same.
-     * If losses is not defined, the gains of the other seat is
-     * subtracted.
-     */
-    losses: AmountKeywordRecord;
-};
-/**
- * If two seats can satisfy each other's wants, trade enough to
- * satisfy the wants of both seats and exit both seats.
- *
- * The surplus remains with the original seat. For example if seat A
- * gives 5 moola and seat B only wants 3 moola, seat A retains 2
- * moola.
- *
- * If the swap fails, no assets are transferred, both seats will fail,
- * and the function throws.
- *
- * The keywords for both seats must match.
- */
-type Swap = (zcf: ZCF, leftSeat: ZCFSeat, rightSeat: ZCFSeat) => string;
-/**
- * Swap such that both seats gain what they want and lose everything
- * that they gave. Only good for exact and entire swaps where each
- * seat wants everything that the other seat has. The benefit of using
- * this method is that the keywords of each seat do not matter.
- *
- * If the swap fails, no assets are transferred, both seats will fail,
- * and the function throws.
- */
-type SwapExact = (zcf: ZCF, leftSeat: ZCFSeat, rightSeat: ZCFSeat) => string;
-/**
- * A mapping of keywords to keywords.
- */
-type KeywordKeywordRecord = Record<Keyword, Keyword>;
-/**
- * Given a mapping of keywords to keywords, invert the keys and
- * values. This is used to map the offers made to another contract
- * back to the keywords used in the first contract.
- */
-type Reverse = (keywordRecord?: KeywordKeywordRecord | undefined) => KeywordKeywordRecord;
-/**
- * Remap the keywords of an amountKeywordRecord, issuerKeywordRecord, or a
- * PaymentPKeywordRecord according to a mapping. This is used to remap
- * from keywords used in contractA to keywords used in contractB and
- * vice versa in `offerTo`
- */
-type MapKeywords = (keywordRecord: AmountKeywordRecord | PaymentPKeywordRecord | IssuerKeywordRecord | undefined, keywordMapping: KeywordKeywordRecord) => any;
-type Ratio = {
-    numerator: Amount<'nat'>;
-    denominator: Amount<'nat'>;
-};
-type ScaleAmount = (amount: Amount<'nat'>, ratio: Ratio) => Amount<'nat'>;
-//# sourceMappingURL=types.d.ts.map

package/src/contractSupport/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";UAMc,OAAO;;;;;WACP,mBAAmB;;;;;;;;YAEnB,mBAAmB;;;;;;;;;;;;;;;kBAqBtB,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;;;;;;;uBAcR,GAAG,YACH,OAAO,aACP,OAAO,KACL,MAAM;;;;4BAIN,OAAO,OAAO,EAAC,OAAO,CAAC;;;;;;qEAYvB,oBAAoB;;;;;;;mCAWtB,mBAAmB,GAAG,qBAAqB,GAAG,mBAAmB,GAAG,SAAS,kBAC7E,oBAAoB;;eAKjB,OAAO,KAAK,CAAC;iBACb,OAAO,KAAK,CAAC;;4BAKhB,OAAO,KAAK,CAAC,SACb,KAAK,KACH,OAAO,KAAK,CAAC"}

package/src/contractSupport/zoeHelpers.d.ts

@@ -1,30 +0,0 @@
-export const defaultAcceptanceMsg: "The offer has been accepted. Once the contract has been completed, please check your payout";
-export function assertIssuerKeywords(zcf: any, expected: any): void;
-export function satisfies(zcf: ZCF, seat: ZcfSeatPartial, update: AmountKeywordRecord): 0 | 1;
-/** @type {Swap} */
-export const swap: Swap;
-/** @type {SwapExact} */
-export const swapExact: SwapExact;
-export function fitProposalShape(seat: ZCFSeat, proposalShape: Pattern): void;
-export function assertProposalShape(seat: ZCFSeat, expected: ExpectedRecord): void;
-export function assertNatAssetKind(zcf: any, brand: any): void;
-export const depositToSeatSuccessMsg: "Deposit and reallocation successful.";
-export function depositToSeat(zcf: ZCF, recipientSeat: ZCFSeat, amounts: AmountKeywordRecord, payments: PaymentPKeywordRecord): Promise<string>;
-export function withdrawFromSeat(zcf: ZCF, seat: ZCFSeat, amounts: AmountKeywordRecord): Promise<PaymentPKeywordRecord>;
-export function saveAllIssuers(zcf: ZCF, issuerKeywordRecord?: IssuerKeywordRecord): Promise<(IssuerRecord<any> | undefined)[]>;
-/** @type {MapKeywords} */
-export const mapKeywords: MapKeywords;
-export function offerTo<Args extends unknown, Result extends unknown>(zcf: ZCF, invitation: ERef<Invitation<R, A>>, keywordMapping: KeywordKeywordRecord | undefined, proposal: Proposal, fromSeat: ZCFSeat, toSeat?: ZCFSeat | undefined, offerArgs?: Args | undefined): Promise<{
-    userSeatPromise: Promise<UserSeat<Result>>;
-    deposited: Promise<AmountKeywordRecord>;
-}>;
-export type ZcfSeatPartial = {
-    getProposal: () => ProposalRecord;
-    getCurrentAllocation: () => Allocation;
-};
-export type ExpectedRecord = {
-    want?: Record<string, null> | undefined;
-    give?: Record<string, null> | undefined;
-    exit?: Partial<Record<never, null>> | undefined;
-};
-//# sourceMappingURL=zoeHelpers.d.ts.map

package/src/contractSupport/zoeHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zoeHelpers.d.ts","sourceRoot":"","sources":["zoeHelpers.js"],"names":[],"mappings":"AASA,iIAAkI;AAM3H,oEAON;AAuBM,+BALI,GAAG,QACH,cAAc,UACd,mBAAmB,GACjB,CAAC,GAAC,CAAC,CAOf;AAED,mBAAmB;AACnB,mBADW,IAAI,CAkBb;AAEF,wBAAwB;AACxB,wBADW,SAAS,CAqBlB;AAiBK,uCAHI,OAAO,iBACP,OAAO,QAIgD;AAsB3D,0CAHI,OAAO,YACP,cAAc,QA+BxB;AAGM,+DAGN;AAED,6EAA8E;AAavE,mCANI,GAAG,iBACH,OAAO,WACP,mBAAmB,YACnB,qBAAqB,GACnB,QAAQ,MAAM,CAAC,CA8B3B;AAYM,sCALI,GAAG,QACH,OAAO,WACP,mBAAmB,GACjB,QAAQ,qBAAqB,CAAC,CAQ1C;AAWM,oCAJI,GAAG,wBACH,mBAAmB,8CAgB7B;AAED,0BAA0B;AAC1B,0BADW,WAAW,CAYpB;AAiDK,2EAjCI,GAAG,sDAMH,oBAAoB,GAAG,SAAS,YAKhC,QAAQ,YAGR,OAAO;;eAU2D,QAAQ,mBAAmB,CAAC;GA+DxG;;iBAzVa,MAAM,cAAc;0BACpB,MAAM,UAAU"}

package/src/contracts/atomicSwap.d.ts

@@ -1,16 +0,0 @@
-/**
- * Trade one item for another.
- * https://agoric.com/documentation/zoe/guide/contracts/atomic-swap.html
- *
- * The initial offer is { give: { Asset: A }, want: { Price: B } }.
- * The outcome from the first offer is an invitation for the second party,
- * who should offer { give: { Price: B }, want: { Asset: A } }, with a want
- * amount no greater than the original's give, and a give amount at least as
- * large as the original's want.
- *
- * @param {ZCF} zcf
- */
-export function start(zcf: ZCF): {
-    creatorInvitation: Promise<Invitation<R, A>>;
-};
-//# sourceMappingURL=atomicSwap.d.ts.map

package/src/contracts/atomicSwap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"atomicSwap.d.ts","sourceRoot":"","sources":["atomicSwap.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;GAWG;AACH,2BAFW,GAAG;;EAqCb"}

package/src/contracts/auction/assertBidSeat.d.ts

@@ -1,2 +0,0 @@
-export function assertBidSeat(zcf: any, sellSeat: any, bidSeat: any): void;
-//# sourceMappingURL=assertBidSeat.d.ts.map

package/src/contracts/auction/assertBidSeat.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"assertBidSeat.d.ts","sourceRoot":"","sources":["assertBidSeat.js"],"names":[],"mappings":"AAGO,2EASN"}

package/src/contracts/auction/firstPriceLogic.d.ts

@@ -1,2 +0,0 @@
-export function calcWinnerAndClose(zcf: ZCF, sellSeat: ZCFSeat, bidSeats: Array<ZCFSeat>): void;
-//# sourceMappingURL=firstPriceLogic.d.ts.map

package/src/contracts/auction/firstPriceLogic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"firstPriceLogic.d.ts","sourceRoot":"","sources":["firstPriceLogic.js"],"names":[],"mappings":"AAOO,wCAJI,GAAG,YACH,OAAO,YACP,MAAM,OAAO,CAAC,QAoDxB"}

package/src/contracts/auction/index.d.ts

@@ -1,56 +0,0 @@
-/**
- * NOT TO BE USED IN PRODUCTION CODE. BIDS ARE PUBLIC. An auction
- * contract in which the seller offers an Asset for sale, and states a
- * minimum price. The auction closes at the deadline specified by the
- * timeAuthority, bidDuration, winnerPriceOption parameters in the terms provided by
- * the creator of the contract instance.
- * Winner price option can be `first-price` or `second-price`, default to `second-price`.
- *
- * startInstance() specifies the issuers and the terms. An invitation
- * for the seller is returned as the creatorInvitation. The seller's
- * offer should look like { give: { Asset: asset }, want: { Ask:
- * minimumBidAmount}} The asset can be non-fungible, but the Ask
- * amount should be of a fungible brand. The bidder invitations can be
- * made by calling makeBidInvitation on the object returned from the
- * seller's offer. Each bidder can submit an offer: { give: { Bid:
- * null } want: { Asset: null } }.
- *
- * @param {ZCF<{
- * timeAuthority: import('@agoric/time/src/types').TimerService,
- * winnerPriceOption?: FIRST_PRICE | SECOND_PRICE,
- * bidDuration: bigint,
- * }>} zcf
- */
-export function start(zcf: ZCF<{
-    timeAuthority: import('@agoric/time/src/types').TimerService;
-    winnerPriceOption?: "first-price" | "second-price" | undefined;
-    bidDuration: bigint;
-}>): {
-    creatorInvitation: Promise<Invitation<R, A>>;
-    publicFacet: {
-        getCurrentBids: () => any[] | "Bids are hidden for \"second price\" auctions";
-        getSessionDetails: () => {
-            auctionedAssets: any;
-            minimumBid: any;
-            winnerPriceOption: string;
-            closesAfter: any;
-            bidDuration: bigint;
-            timeAuthority: import("@agoric/time/src/types").TimerService;
-            bids: string | any[];
-        };
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getCurrentBids: () => any[] | "Bids are hidden for \"second price\" auctions";
-        getSessionDetails: () => {
-            auctionedAssets: any;
-            minimumBid: any;
-            winnerPriceOption: string;
-            closesAfter: any;
-            bidDuration: bigint;
-            timeAuthority: import("@agoric/time/src/types").TimerService;
-            bids: string | any[];
-        };
-    }>;
-};
-export const FIRST_PRICE: "first-price";
-export const SECOND_PRICE: "second-price";
-//# sourceMappingURL=index.d.ts.map

package/src/contracts/auction/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;mBALkB,OAAO,wBAAwB,EAAE,YAAY;;iBAE/C,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;EA2HrB;AAlJD,wCAAkC;AAClC,0CAAoC"}

package/src/contracts/auction/secondPriceLogic.d.ts

@@ -1,2 +0,0 @@
-export function calcWinnerAndClose(zcf: ZCF, sellSeat: ZCFSeat, bidSeats: Array<ZCFSeat>): void;
-//# sourceMappingURL=secondPriceLogic.d.ts.map

package/src/contracts/auction/secondPriceLogic.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"secondPriceLogic.d.ts","sourceRoot":"","sources":["secondPriceLogic.js"],"names":[],"mappings":"AAOO,wCAJI,GAAG,YACH,OAAO,YACP,MAAM,OAAO,CAAC,QA+DxB"}

package/src/contracts/automaticRefund.d.ts

@@ -1,25 +0,0 @@
-/**
- * This is a very trivial contract to explain and test Zoe.
- * AutomaticRefund just gives you back what you put in.
- * AutomaticRefund tells Zoe to complete the
- * offer, which gives the user their payout through Zoe. Other
- * contracts will use these same steps, but they will have more
- * sophisticated logic and interfaces.
- *
- * Since the contract doesn't attempt any reallocation, the offer can contain
- * anything in `give` and `want`. The amount in `give` will be returned, and
- * `want` will be ignored.
- *
- * @param {ZCF<{}>} zcf
- */
-export function start(zcf: ZCF<{}>): {
-    creatorInvitation: Promise<Invitation<R, A>>;
-    publicFacet: {
-        getOffersCount: () => bigint;
-        makeInvitation: () => Promise<Invitation<R, A>>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getOffersCount: () => bigint;
-        makeInvitation: () => Promise<Invitation<R, A>>;
-    }>;
-};
-//# sourceMappingURL=automaticRefund.d.ts.map

package/src/contracts/automaticRefund.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"automaticRefund.d.ts","sourceRoot":"","sources":["automaticRefund.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,2BAFW,IAAI,EAAE,CAAC;;;;;;;;;EAqBjB"}

package/src/contracts/autoswap.d.ts

@@ -1,43 +0,0 @@
-/**
- * Autoswap is a rewrite of Uniswap. Please see the documentation for
- * more https://agoric.com/documentation/zoe/guide/contracts/autoswap.html
- *
- * When the contract is instantiated, the two tokens (Central and Secondary) are
- * specified in the issuerKeywordRecord. There is no behavioral difference
- * between the two when trading; the names were chosen for consistency with our
- * constant product AMM. When trading, use the keywords In and Out to specify
- * the amount to be paid in, and the amount to be received.
- *
- * When adding or removing liquidity, the amounts deposited must be in
- * proportion to the current balances in the pool. The amount of the Central
- * asset is used as the basis. The Secondary assets must be added in proportion.
- * If less Secondary is provided than required, we refuse the offer. If more is
- * provided than is required, we return the excess.
- *
- * Before trading can take place, it is necessary to add liquidity using
- * makeAddLiquidityInvitation(). Separate invitations are available for adding
- * and removing liquidity, and for doing swaps. Other API operations support
- * price checks and checking the size of the liquidity pool.
- *
- * The swap operation requires either the input amount or the output amount to
- * be specified. makeSwapInInvitation treats the give amount as definitive,
- * while makeSwapOutInvitation honors the want amount. With swapIn, a want
- * amount can be specified, and if the offer can't be satisfied, the offer will
- * be refunded. Similarly with swapOut, the want amount will be satisfied if
- * possible. If more is provided as the give amount than necessary, the excess
- * will be refunded. If not enough is provided, the offer will be refunded.
- *
- * The publicFacet can make new invitations (makeSwapInInvitation,
- * makeSwapOutInvitation, makeAddLiquidityInvitation, and
- * makeRemoveLiquidityInvitation), tell how much would be paid for a given input
- * (getInputPrice), or how much would be earned by depositing a specified amount
- * (getOutputPrice). In addition, there are requests for the LiquidityIssuer
- * (getLiquidityIssuer), the current outstanding liquidity (getLiquiditySupply),
- * and the current balances in the pool (getPoolAllocation).
- *
- * @param {ZCF} zcf
- */
-export function start(zcf: ZCF): Promise<{
-    publicFacet: AutoswapPublicFacet;
-}>;
-//# sourceMappingURL=autoswap.d.ts.map

package/src/contracts/autoswap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"autoswap.d.ts","sourceRoot":"","sources":["autoswap.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2BAFW,GAAG;;GAoVb"}

package/src/contracts/barterExchange.d.ts

@@ -1,22 +0,0 @@
-/**
- * This Barter Exchange accepts offers to trade arbitrary goods for other
- * things. It doesn't require registration of Issuers. If two offers satisfy
- * each other, it exchanges the specified amounts in each side's want clause.
- * https://agoric.com/documentation/zoe/guide/contracts/barter-exchange.html
- *
- * The Barter Exchange only accepts offers that look like
- * { give: { In: amount }, want: { Out: amount} }
- * The want amount will be matched, while the give amount is a maximum. Each
- * successful trader gets their `want` and may trade with counter-parties who
- * specify any amount up to their specified `give`.
- *
- * @param {ZCF} zcf
- */
-export function start(zcf: ZCF): {
-    publicFacet: {
-        makeInvitation: () => Promise<Invitation<R, A>>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        makeInvitation: () => Promise<Invitation<R, A>>;
-    }>;
-};
-//# sourceMappingURL=barterExchange.d.ts.map

package/src/contracts/barterExchange.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"barterExchange.d.ts","sourceRoot":"","sources":["barterExchange.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;GAaG;AACH,2BAFW,GAAG;;;;;;EA+Gb"}

package/src/contracts/callSpread/calculateShares.d.ts

@@ -1,2 +0,0 @@
-export function calculateShares(collateralBrand: Brand<AssetKind>, price: Amount<"nat">, strikePrice1: Amount<"nat">, strikePrice2: Amount<"nat">): CalculateSharesReturn;
-//# sourceMappingURL=calculateShares.d.ts.map

package/src/contracts/callSpread/calculateShares.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"calculateShares.d.ts","sourceRoot":"","sources":["calculateShares.js"],"names":[],"mappings":"AAeqB,0KAyBN"}