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

package/src/contracts/mintPayments.d.ts

@@ -1,30 +0,0 @@
-/**
- * This is a very simple contract that creates a new issuer and mints payments
- * from it, in order to give an example of how that can be done.  This contract
- * sends new tokens to anyone who has an invitation.
- *
- * The expectation is that most contracts that want to do something similar
- * would use the ability to mint new payments internally rather than sharing
- * that ability widely as this one does.
- *
- * To pay others in tokens, the creator of the instance can make
- * invitations for them, which when used to make an offer, will payout
- * the specified amount of tokens.
- *
- * @param {ZCF} zcf
- */
-export function start(zcf: ZCF): Promise<{
-    creatorFacet: {
-        makeInvitation: (value?: bigint) => Promise<Invitation<R, A>>;
-        getTokenIssuer: () => Issuer<"nat">;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        makeInvitation: (value?: bigint) => Promise<Invitation<R, A>>;
-        getTokenIssuer: () => Issuer<"nat">;
-    }>;
-    publicFacet: {
-        getTokenIssuer: () => Issuer<"nat">;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getTokenIssuer: () => Issuer<"nat">;
-    }>;
-}>;
-//# sourceMappingURL=mintPayments.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"mintPayments.d.ts","sourceRoot":"","sources":["mintPayments.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,2BAFW,GAAG;;;;;;;;;;;;;GAyCb"}

package/src/contracts/oracle.d.ts

@@ -1,26 +0,0 @@
-export type OracleContract = ContractOf<typeof start>;
-export type OracleStart = typeof start;
-/**
- * This contract provides oracle queries for a fee or for free.
- *
- * @param {ZCF} zcf
- */
-export function start(zcf: ZCF): Promise<{
-    creatorFacet: {
-        initialize(privateParams: any): OracleCreatorFacet;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        initialize(privateParams: any): OracleCreatorFacet;
-    }>;
-    publicFacet: {
-        /** @param {OracleQuery} query */
-        query(query: OracleQuery): Promise<unknown>;
-        /** @param {OracleQuery} query */
-        makeQueryInvitation(query: OracleQuery): Promise<Invitation<R, A>>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        /** @param {OracleQuery} query */
-        query(query: OracleQuery): Promise<unknown>;
-        /** @param {OracleQuery} query */
-        makeQueryInvitation(query: OracleQuery): Promise<Invitation<R, A>>;
-    }>;
-}>;
-//# sourceMappingURL=oracle.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"oracle.d.ts","sourceRoot":"","sources":["oracle.js"],"names":[],"mappings":"6BAyGc,WAAW,YAAY,CAAC;0BACxB,YAAY;AAlG1B;;;;GAIG;AACH,2BAFW,GAAG;;;;;;;QAkDV,iCAAiC;qBAArB,WAAW;QAgBvB,iCAAiC;mCAArB,WAAW;;QAhBvB,iCAAiC;qBAArB,WAAW;QAgBvB,iCAAiC;mCAArB,WAAW;;GAwB1B"}

package/src/contracts/otcDesk.d.ts

@@ -1,79 +0,0 @@
-/**
- * This contract is inspired by the description of an OTC Desk smart
- * contract in this article:
- * https://medium.com/dragonfly-research/unbundling-uniswap-the-future-of-on-chain-market-making-1c7d6948d570
- *
- * The creator of this contract instance can take three actions: add
- * inventory, remove inventory, and make quotes for potential trading
- * partners.
- *
- * To add inventory, the creator of the contract instance can call
- * `E(creatorFacet).makeAddInventoryInvitation(issuerKeywordRecord)`
- * and receive an invitation to add inventory. In this call, they must
- * pass in an issuerKeywordRecord of any issuers they wish to add
- * inventory for, if these issuers have not yet been saved to ZCF.
- * When actually escrowing the inventory as an offer, the proposal
- * must not `want` anything. All of the newly escrowed inventory is
- * taken and reallocated to the marketMakerSeat in the contract.
- *
- * To remove inventory, the creator of the contract instance can call
- * `E(creatorFacet).makeRemoveInventoryInvitation()` and receive an
- * invitation to remove inventory. When making an offer to remove
- * inventory, the proposal should specify the `want`, which will be
- * removed, but should not give anything.
- *
- * To make a quote, the creator can call
- * `E(creatorFacet).makeQuote(price, assets, timeAuthority,
- * deadline)`. `price` and `assets` are amountKeywordRecords that will
- * be used in the coveredCall. The assets are the underlyingAssets in
- * the call option, and the price is used as the strikePrice. The
- * timeAuthority should be a timer, and the deadline can be any time
- * understood by the timer. The quote will be cancelled after the
- * deadline. `makeQuote` returns a covered call option that can be
- * given away for free or sold. Importantly, if the recipient chooses
- * to exercise the option, they can verify that the goods being
- * offered are already escrowed, and the trade is guaranteed to
- * succeed if their proposal matches the quote.
- *
- * @param {ZCF<Record<string, any>>} zcf
- */
-export function start(zcf: ZCF<Record<string, any>>): {
-    creatorFacet: {
-        /**
-         * The inventory can be added in bulk before any quotes are made
-         * or can be added immediately before a quote.
-         *
-         * @param {IssuerKeywordRecord} [issuerKeywordRecord]
-         * @returns {Promise<Payment>}
-         */
-        makeAddInventoryInvitation: (issuerKeywordRecord?: IssuerKeywordRecord | undefined) => Promise<Payment>;
-        /**
-         * The inventory can be removed at any time, since the inventory
-         * used for active quotes is escrowed separately within the coveredCall
-         * instance.
-         *
-         * @returns {Promise<Payment>}
-         */
-        makeRemoveInventoryInvitation: () => Promise<Payment>;
-        makeQuote: (price: AmountKeywordRecord, assets: AmountKeywordRecord, timeAuthority: Timer, deadline: any) => Promise<Payment>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        /**
-         * The inventory can be added in bulk before any quotes are made
-         * or can be added immediately before a quote.
-         *
-         * @param {IssuerKeywordRecord} [issuerKeywordRecord]
-         * @returns {Promise<Payment>}
-         */
-        makeAddInventoryInvitation: (issuerKeywordRecord?: IssuerKeywordRecord | undefined) => Promise<Payment>;
-        /**
-         * The inventory can be removed at any time, since the inventory
-         * used for active quotes is escrowed separately within the coveredCall
-         * instance.
-         *
-         * @returns {Promise<Payment>}
-         */
-        makeRemoveInventoryInvitation: () => Promise<Payment>;
-        makeQuote: (price: AmountKeywordRecord, assets: AmountKeywordRecord, timeAuthority: Timer, deadline: any) => Promise<Payment>;
-    }>;
-};
-//# sourceMappingURL=otcDesk.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"otcDesk.d.ts","sourceRoot":"","sources":["otcDesk.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,2BAFW,IAAI,OAAO,MAAM,EAAE,GAAG,CAAC,CAAC;;QAoE/B;;;;;;WAMG;+FADU,QAAQ,OAAO,CAAC;QAM7B;;;;;;WAMG;6CADU,QAAQ,OAAO,CAAC;2BAzEpB,mBAAmB,UACnB,mBAAmB,iBACnB,KAAK,YACL,GAAG,KACD,QAAQ,OAAO,CAAC;;QAqD3B;;;;;;WAMG;+FADU,QAAQ,OAAO,CAAC;QAM7B;;;;;;WAMG;6CADU,QAAQ,OAAO,CAAC;2BAzEpB,mBAAmB,UACnB,mBAAmB,iBACnB,KAAK,YACL,GAAG,KACD,QAAQ,OAAO,CAAC;;EA8E9B"}

package/src/contracts/priceAggregator.d.ts

@@ -1,91 +0,0 @@
-export type ParsableNumber = bigint | number | string;
-export type OraclePriceSubmission = Readonly<ParsableNumber | {
-    data: ParsableNumber;
-}>;
-export type Price = ParsableNumber | Ratio;
-export type PriceAggregatorContract = ContractOf<typeof start>;
-/**
- * @deprecated use fluxAggregator
- *
- * This contract aggregates price values from a set of oracles and provides a
- * PriceAuthority for their median. This naive method is game-able and so this module
- * is a stub until we complete what is now in `fluxAggregatorKit.js`.
- *
- * @param {ZCF<{
- * timer: import('@agoric/time/src/types').TimerService,
- * POLL_INTERVAL: bigint,
- * brandIn: Brand<'nat'>,
- * brandOut: Brand<'nat'>,
- * unitAmountIn: Amount<'nat'>,
- * }>} zcf
- * @param {{
- * marshaller: Marshaller,
- * quoteMint?: ERef<Mint<'set'>>,
- * storageNode: ERef<StorageNode>,
- * }} privateArgs
- */
-export function start(zcf: ZCF<{
-    timer: import('@agoric/time/src/types').TimerService;
-    POLL_INTERVAL: bigint;
-    brandIn: Brand<'nat'>;
-    brandOut: Brand<'nat'>;
-    unitAmountIn: Amount<'nat'>;
-}>, privateArgs: {
-    marshaller: Marshaller;
-    quoteMint?: ERef<Mint<"set">> | undefined;
-    storageNode: ERef<StorageNode>;
-}): Promise<{
-    creatorFacet: {
-        /**
-         * An "oracle invitation" is an invitation to be able to submit data to
-         * include in the priceAggregator's results.
-         *
-         * The offer result from this invitation is a OracleAdmin, which can be used
-         * directly to manage the price submissions as well as to terminate the
-         * relationship.
-         *
-         * @param {Instance | string} [oracleKey]
-         */
-        makeOracleInvitation: (oracleKey?: string | Instance | undefined) => Promise<Invitation<R, A>>;
-        /** @param {OracleKey} oracleKey */
-        deleteOracle: (oracleKey: OracleKey) => Promise<void>;
-        /**
-         * @param {Instance | string} [oracleInstance]
-         * @param {OracleQuery} [query]
-         * @returns {Promise<OracleAdmin<Price>>}
-         */
-        initOracle: (oracleInstance?: string | Instance | undefined, query?: OracleQuery | undefined) => Promise<OracleAdmin<Price>>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        /**
-         * An "oracle invitation" is an invitation to be able to submit data to
-         * include in the priceAggregator's results.
-         *
-         * The offer result from this invitation is a OracleAdmin, which can be used
-         * directly to manage the price submissions as well as to terminate the
-         * relationship.
-         *
-         * @param {Instance | string} [oracleKey]
-         */
-        makeOracleInvitation: (oracleKey?: string | Instance | undefined) => Promise<Invitation<R, A>>;
-        /** @param {OracleKey} oracleKey */
-        deleteOracle: (oracleKey: OracleKey) => Promise<void>;
-        /**
-         * @param {Instance | string} [oracleInstance]
-         * @param {OracleQuery} [query]
-         * @returns {Promise<OracleAdmin<Price>>}
-         */
-        initOracle: (oracleInstance?: string | Instance | undefined, query?: OracleQuery | undefined) => Promise<OracleAdmin<Price>>;
-    }>;
-    publicFacet: {
-        getPriceAuthority(): PriceAuthority;
-        getSubscriber: () => StoredSubscriber<unknown>;
-        /** Diagnostic tool */
-        getRoundCompleteNotifier(): Promise<Notifier<any>>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getPriceAuthority(): PriceAuthority;
-        getSubscriber: () => StoredSubscriber<unknown>;
-        /** Diagnostic tool */
-        getRoundCompleteNotifier(): Promise<Notifier<any>>;
-    }>;
-}>;
-//# sourceMappingURL=priceAggregator.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"priceAggregator.d.ts","sourceRoot":"","sources":["priceAggregator.js"],"names":[],"mappings":"6BAqCc,MAAM,GAAG,MAAM,GAAG,MAAM;oCAEzB,SAAS,cAAc,GAAG;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,CAAC;oBAGlD,cAAc,GAAG,KAAK;sCAmlBtB,WAAW,YAAY,CAAC;AA9kBtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH;WAZU,OAAO,wBAAwB,EAAE,YAAY;mBACrC,MAAM;aACZ,MAAM,KAAK,CAAC;cACX,MAAM,KAAK,CAAC;kBACR,OAAO,KAAK,CAAC;;gBAGf,UAAU;;iBAET,KAAK,WAAW,CAAC;;;QAiX7B;;;;;;;;;WASG;;QAsDH,mCAAmC;kCAAvB,SAAS;QAarB;;;;WAIG;yGADU,QAAQ,YAAY,KAAK,CAAC,CAAC;;QA/ExC;;;;;;;;;WASG;;QAsDH,mCAAmC;kCAAvB,SAAS;QAarB;;;;WAIG;yGADU,QAAQ,YAAY,KAAK,CAAC,CAAC;;;;;QAmHxC,sBAAsB;;;;;QAAtB,sBAAsB;;;GAOzB"}

package/src/contracts/priceAggregatorTypes.d.ts

@@ -1,77 +0,0 @@
-type OracleAdmin<R extends unknown> = {
-    /**
-     * Remove the oracle from the aggregator
-     */
-    delete: () => Promise<void>;
-    /**
-     * Rather than waiting for the polling query, push a result directly from this oracle
-     */
-    pushResult: (result: R) => Promise<void>;
-};
-type OracleKey = {} | string;
-type PriceAggregatorKit = Pick<import("./priceAggregator").PriceAggregatorContract, 'creatorFacet' | 'publicFacet'>;
-type OracleQuery = Record<string, unknown> & {
-    kind?: string;
-    increment?: bigint;
-};
-/**
- * The public methods accessible from the contract instance
- */
-type OraclePublicFacet = {
-    /**
-     * Create an invitation for an oracle query
-     */
-    makeQueryInvitation: (query: OracleQuery) => ERef<Invitation>;
-    /**
-     * Make an unpaid query
-     */
-    query: (query: OracleQuery) => ERef<unknown>;
-};
-type OracleCreatorFacetMakeWithdrawInvitation = (total?: boolean | undefined) => ERef<Invitation>;
-/**
- * The private methods accessible from the contract instance
- */
-type OracleCreatorFacet = {
-    /**
-     * Get the current fee amounts
-     */
-    getCurrentFees: () => AmountKeywordRecord;
-    /**
-     * Create an invitation to withdraw fees
-     */
-    makeWithdrawInvitation: OracleCreatorFacetMakeWithdrawInvitation;
-    /**
-     * Make an invitation to withdraw all fees and shutdown
-     */
-    makeShutdownInvitation: () => Promise<Invitation>;
-};
-type OraclePrivateParameters = {
-    oracleHandler: OracleHandler;
-};
-type OracleInitializationFacet = {
-    initialize: (privateParams: OraclePrivateParameters) => OracleCreatorFacet;
-};
-type OracleKit = {
-    creatorFacet: OracleCreatorFacet;
-    publicFacet: OraclePublicFacet;
-    instance: Instance;
-};
-type OracleReply = {
-    reply: unknown;
-    requiredFee?: Amount<AssetKind> | undefined;
-};
-type OracleHandler = {
-    /**
-     * Callback to reply to a query
-     */
-    onQuery: (query: OracleQuery, fee: Amount) => Promise<OracleReply>;
-    /**
-     * Notice an error
-     */
-    onError: (query: OracleQuery, reason: unknown) => void;
-    /**
-     * Notice a successful reply
-     */
-    onReply: (query: OracleQuery, reply: unknown, requiredFee: Amount | undefined) => void;
-};
-//# sourceMappingURL=priceAggregatorTypes.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"priceAggregatorTypes.d.ts","sourceRoot":"","sources":["priceAggregatorTypes.js"],"names":[],"mappings":";;;;YAGc,MAAM,QAAQ,IAAI,CAAC;;;;yBAEV,CAAC,KAAK,QAAQ,IAAI,CAAC;;iBAK7B,EAAE,GAAG,MAAM;0BAIX,KAAK,OAAO,mBAAmB,EAAE,uBAAuB,EAAE,cAAc,GAAG,aAAa,CAAC;mBAIzF,OAAO,MAAM,EAAE,OAAO,CAAC,GAAG;IACtC,IAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAW,CAAC,EAAE,MAAM,CAAC;CAClB;;;;;;;;iCAMkB,WAAW,KAAK,KAAK,UAAU,CAAC;;;;mBAEhC,WAAW,KAAK,KAAK,OAAO,CAAC;;iFAOtC,KAAK,UAAU,CAAC;;;;;;;;oBAMf,MAAM,mBAAmB;;;;4BAEzB,wCAAwC;;;;4BAExC,MAAM,QAAQ,UAAU,CAAC;;;mBAMzB,aAAa;;;gCAKG,uBAAuB,KAC7C,kBAAkB;;;kBAKZ,kBAAkB;iBAClB,iBAAiB;cACjB,QAAQ;;;WAKR,OAAO;;;;;;;qBAMC,WAAW,OAAO,MAAM,KAAK,QAAQ,WAAW,CAAC;;;;qBAEjD,WAAW,UAAU,OAAO,KAAK,IAAI;;;;qBAErC,WAAW,SACX,OAAO,eACD,MAAM,GAAG,SAAS,KACtC,IAAI"}

package/src/contracts/scaledPriceAuthority.d.ts

@@ -1,23 +0,0 @@
-export function prepare(zcf: ZCF<ScaledPriceAuthorityOpts>, privateArgs: object, baggage: MapStore<string, any>): Promise<{
-    publicFacet: {
-        getPriceAuthority: () => Promise<PriceAuthority>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        getPriceAuthority: () => Promise<PriceAuthority>;
-    }>;
-}>;
-export type ScaledPriceAuthorityOpts = {
-    sourcePriceAuthority: ERef<PriceAuthority>;
-    /**
-     * - sourceAmountIn:targetAmountIn
-     */
-    scaleIn: Ratio;
-    /**
-     * - sourceAmountOut:targetAmountOut
-     */
-    scaleOut: Ratio;
-    /**
-     * - targetAmountIn:targetAmountOut
-     */
-    initialPrice?: Ratio | undefined;
-};
-//# sourceMappingURL=scaledPriceAuthority.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"scaledPriceAuthority.d.ts","sourceRoot":"","sources":["scaledPriceAuthority.js"],"names":[],"mappings":"AAiCO,6BALI,IAAI,wBAAwB,CAAC,eAC7B,MAAM;;;;;;GA0DhB;;0BA1Ea,KAAK,cAAc,CAAC;;;;aACpB,KAAK;;;;cACL,KAAK"}

package/src/contracts/sellItems.d.ts

@@ -1,30 +0,0 @@
-/**
- * Sell items in exchange for money. Items may be fungible or
- * non-fungible and multiple items may be bought at once. Money must
- * be fungible.
- *
- * The `pricePerItem` is to be set in the terms. It is expected that all items
- * are sold for the same uniform price.
- *
- * The initial offer should be { give: { Items: items } }, accompanied by
- * terms as described above.
- * Buyers use offers that match { want: { Items: items } give: { Money: m } }.
- * The items provided should match particular items that the seller still has
- * available to sell, and the money should be pricePerItem times the number of
- * items requested.
- *
- * When all the items have been sold, the contract will terminate, triggering
- * the creator's payout. If the creator has an onDemand exit clause, they can
- * exit early to collect their winnings. The remaining items will still be
- * available for sale, but the creator won't be able to collect later earnings.
- *
- * @param {ZCF<{pricePerItem: Amount<'nat'>}>} zcf
- */
-export function start(zcf: ZCF<{
-    pricePerItem: Amount<'nat'>;
-}>): {
-    creatorFacet: SellItemsCreatorFacet;
-    creatorInvitation: Promise<Invitation<R, A>>;
-    publicFacet: SellItemsPublicFacet;
-};
-//# sourceMappingURL=sellItems.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"sellItems.d.ts","sourceRoot":"","sources":["sellItems.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;kBAF8B,OAAO,KAAK,CAAC;;;;;EAuH1C"}

package/src/contracts/simpleExchange.d.ts

@@ -1,37 +0,0 @@
-/**
- * SimpleExchange is an exchange with a simple matching algorithm, which allows
- * an unlimited number of parties to create new orders or accept existing
- * orders. The notifier allows callers to find the current list of orders.
- * https://agoric.com/documentation/zoe/guide/contracts/simple-exchange.html
- *
- * The SimpleExchange uses Asset and Price as its keywords. The contract treats
- * the two keywords symmetrically. New offers can be created and existing offers
- * can be accepted in either direction.
- *
- * { give: { 'Asset', simoleans(5n) }, want: { 'Price', quatloos(3) } }
- * { give: { 'Price', quatloos(8) }, want: { 'Asset', simoleans(3n) } }
- *
- * The Asset is treated as an exact amount to be exchanged, while the
- * Price is a limit that may be improved on. This simple exchange does
- * not partially fill orders.
- *
- * The publicFacet is returned from the contract.
- *
- * @param {ZCF} zcf
- */
-export function start(zcf: ZCF): {
-    publicFacet: {
-        makeInvitation: () => Promise<Invitation<R, A>>;
-        getNotifier: () => Notifier<{
-            buys: any;
-            sells: any;
-        }>;
-    } & import("@endo/eventual-send").RemotableBrand<{}, {
-        makeInvitation: () => Promise<Invitation<R, A>>;
-        getNotifier: () => Notifier<{
-            buys: any;
-            sells: any;
-        }>;
-    }>;
-};
-//# sourceMappingURL=simpleExchange.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"simpleExchange.d.ts","sourceRoot":"","sources":["simpleExchange.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2BAFW,GAAG;;;;;;;;;;;;;;EAgHb"}

package/src/contracts/types.d.ts

@@ -1,80 +0,0 @@
-type SellItemsPublicFacet = {
-    getItemsIssuer: () => Issuer;
-    getAvailableItems: () => Amount;
-};
-type SellItemsCreatorOnly = {
-    makeBuyerInvitation: () => Promise<Invitation>;
-};
-type SellItemsCreatorFacet = SellItemsPublicFacet & SellItemsCreatorOnly;
-type SellItemsParameters = {
-    customValueProperties: Record<string, any>;
-    count: number;
-    moneyIssuer: Issuer;
-    sellItemsInstallation: Installation;
-    pricePerItem: Amount;
-};
-type SellItemsResult = {
-    sellItemsCreatorSeat: UserSeat;
-    sellItemsCreatorFacet: SellItemsCreatorFacet;
-    sellItemsInstance: Instance;
-    sellItemsPublicFacet: SellItemsPublicFacet;
-};
-type MintAndSellNFTCreatorFacet = {
-    sellTokens: (sellParams: SellItemsParameters) => Promise<SellItemsResult>;
-    getIssuer: () => Issuer;
-};
-type AutomaticRefundPublicFacet = {
-    getOffersCount: () => bigint;
-    makeInvitation: () => Promise<Invitation>;
-};
-type AutoswapPublicFacet = {
-    /**
-     * synonym for
-     * makeSwapInInvitation
-     */
-    makeSwapInvitation: () => Promise<Invitation>;
-    /**
-     * make an invitation
-     * that allows one to do a swap in which the In amount is specified and the Out
-     * amount is calculated
-     */
-    makeSwapInInvitation: () => Promise<Invitation>;
-    /**
-     * make an invitation
-     * that allows one to do a swap in which the Out amount is specified and the In
-     * amount is calculated
-     */
-    makeSwapOutInvitation: () => Promise<Invitation>;
-    /**
-     * make an
-     * invitation that allows one to add liquidity to the pool.
-     */
-    makeAddLiquidityInvitation: () => Promise<Invitation>;
-    /**
-     * make an
-     * invitation that allows one to remove liquidity from the pool.
-     */
-    makeRemoveLiquidityInvitation: () => Promise<Invitation>;
-    getLiquidityIssuer: () => Issuer;
-    /**
-     * get the current value of
-     * liquidity held by investors.
-     */
-    getLiquiditySupply: () => bigint;
-    /**
-     * calculate the amount of brandOut that will be returned if the amountIn is
-     * offered using makeSwapInInvitation at the current price.
-     */
-    getInputPrice: (amountIn: Amount, brandOut: Brand) => Amount;
-    /**
-     * calculate the amount of brandIn that is required in order to get amountOut
-     * using makeSwapOutInvitation at the current price
-     */
-    getOutputPrice: (amountOut: Amount, brandIn: Brand) => Amount;
-    /**
-     * get an
-     * AmountKeywordRecord showing the current balances in the pool.
-     */
-    getPoolAllocation: () => Record<string, Amount>;
-};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["types.js"],"names":[],"mappings":";oBAEc,MAAM,MAAM;uBACZ,MAAM,MAAM;;;yBAGZ,MAAM,QAAQ,UAAU,CAAC;;6BAE1B,oBAAoB,GAAG,oBAAoB;;2BAK1C,OAAO,MAAM,EAAE,GAAG,CAAC;WACnB,MAAM;iBACN,MAAM;2BACN,YAAY;kBACZ,MAAM;;;0BAGN,QAAQ;2BACR,qBAAqB;uBACrB,QAAQ;0BACR,oBAAoB;;;6BAGP,mBAAmB,KAAK,QAAQ,eAAe,CAAC;eAC7D,MAAM,MAAM;;;oBAKZ,MAAM,MAAM;oBACZ,MAAM,QAAQ,UAAU,CAAC;;;;;;;wBAKzB,MAAM,QAAQ,UAAU,CAAC;;;;;;0BAEzB,MAAM,QAAQ,UAAU,CAAC;;;;;;2BAGzB,MAAM,QAAQ,UAAU,CAAC;;;;;gCAGzB,MAAM,QAAQ,UAAU,CAAC;;;;;mCAEzB,MAAM,QAAQ,UAAU,CAAC;wBAEzB,MAAM,MAAM;;;;;wBACZ,MAAM,MAAM;;;;;8BAED,MAAM,YAAY,KAAK,KAAK,MAAM;;;;;gCAGjC,MAAM,WAAW,KAAK,KAAK,MAAM;;;;;uBAG7C,MAAM,OAAO,MAAM,EAAE,MAAM,CAAC"}

package/src/handleWarning.d.ts

@@ -1,3 +0,0 @@
-export function handlePWarning(promise: Promise<any>): void;
-export function handlePKitWarning(promiseKit: PromiseRecord<any>): void;
-//# sourceMappingURL=handleWarning.d.ts.map

package/src/handleWarning.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"handleWarning.d.ts","sourceRoot":"","sources":["handleWarning.js"],"names":[],"mappings":"AASO,wCAHI,QAAQ,GAAG,CAAC,GACV,IAAI,CAIhB;AASM,8CAHI,cAAc,GAAG,CAAC,GAChB,IAAI,CAIhB"}

package/src/instanceRecordStorage.d.ts

@@ -1,2 +0,0 @@
-export function makeInstanceRecordStorage(baggage: MapStore<string, any>): (ir: InstanceRecord) => InstanceState;
-//# sourceMappingURL=instanceRecordStorage.d.ts.map

package/src/instanceRecordStorage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"instanceRecordStorage.d.ts","sourceRoot":"","sources":["instanceRecordStorage.js"],"names":[],"mappings":"AA8BO,gFAFW,cAAc,KAAK,aAAa,CAqFjD"}