@agoric/zoe 0.26.3-dev-fa844b5.0 → 0.26.3-dev-21fe8d9.0

package/src/contracts/priceAggregatorTypes.d.ts

@@ -0,0 +1,77 @@
+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<unknown, undefined>>;
+    /**
+     * Make an unpaid query
+     */
+    query: (query: OracleQuery) => unknown;
+};
+type OracleCreatorFacetMakeWithdrawInvitation = (total?: boolean | undefined) => ERef<Invitation<unknown, undefined>>;
+/**
+ * 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?: globalThis.Amount | 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

@@ -0,0 +1 @@
+{"version":3,"file":"priceAggregatorTypes.d.ts","sourceRoot":"","sources":["priceAggregatorTypes.js"],"names":[],"mappings":";;;;YAGc,MAAM,QAAQ,IAAI,CAAC;;;;gBAEnB,CAAC,MAAM,EAAE,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;;;;mBAEX,WAAW;;;;;;;;;;oBAanB,MAAM,mBAAmB;;;;4BAEzB,wCAAwC;;;;4BAExC,MAAM,QAAQ,UAAU,CAAC;;;mBAMzB,aAAa;;;gBAKb,CAAC,aAAa,EAAE,uBAAuB,KAC7C,kBAAkB;;;kBAKZ,kBAAkB;iBAClB,iBAAiB;cACjB,QAAQ;;;WAKR,OAAO;;;;;;;aAMP,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,KAAK,QAAQ,WAAW,CAAC;;;;aAEzD,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,OAAO,KAAK,IAAI;;;;aAE7C,CAAC,KAAK,EAAE,WAAW,EAChC,KAAmB,EAAE,OAAO,EAC5B,WAAyB,EAAE,MAAM,GAAG,SAAS,KACtC,IAAI"}

package/src/contracts/scaledPriceAuthority.d.ts

@@ -0,0 +1,21 @@
+export function prepare(zcf: ZCF<ScaledPriceAuthorityOpts>, privateArgs: object, baggage: import('@agoric/vat-data').Baggage): Promise<{
+    publicFacet: import("@endo/exo").Guarded<{
+        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

@@ -0,0 +1 @@
+{"version":3,"file":"scaledPriceAuthority.d.ts","sourceRoot":"","sources":["scaledPriceAuthority.js"],"names":[],"mappings":"AAiCO,6BALI,IAAI,wBAAwB,CAAC,eAC7B,MAAM,WACN,OAAO,kBAAkB,EAAE,OAAO;;;;GAyD5C;;;;;;aAzEa,KAAK;;;;cACL,KAAK"}

package/src/contracts/sellItems.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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<string, undefined>>;
+    publicFacet: SellItemsPublicFacet;
+};
+//# sourceMappingURL=sellItems.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sellItems.d.ts","sourceRoot":"","sources":["sellItems.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,2BAFW,IAAI;IAAC,YAAY,EAAE,OAAO,KAAK,CAAC,CAAA;CAAC,CAAC;;;;EAuH5C"}

package/src/contracts/simpleExchange.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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<unknown, never>>;
+        getNotifier: () => Notifier<{
+            buys: any;
+            sells: any;
+        }>;
+    } & import("@endo/eventual-send").RemotableBrand<{}, {
+        makeInvitation: () => Promise<Invitation<unknown, never>>;
+        getNotifier: () => Notifier<{
+            buys: any;
+            sells: any;
+        }>;
+    }>;
+};
+//# sourceMappingURL=simpleExchange.d.ts.map

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

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

package/src/contracts/types.d.ts

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1 @@
+{"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;;;gBAGpB,CAAC,UAAU,EAAE,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;;;;;mBAEZ,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,KAAK,MAAM;;;;;oBAG7C,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,KAAK,MAAM;;;;;uBAG7C,MAAM,OAAO,MAAM,EAAE,MAAM,CAAC"}

package/src/handleWarning.d.ts

@@ -0,0 +1,3 @@
+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

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

package/src/instanceRecordStorage.d.ts

@@ -0,0 +1,2 @@
+export function makeInstanceRecordStorage(baggage: import('@agoric/vat-data').Baggage): (ir: InstanceRecord) => InstanceState;
+//# sourceMappingURL=instanceRecordStorage.d.ts.map

package/src/instanceRecordStorage.d.ts.map

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

package/src/internal-types.d.ts

@@ -0,0 +1,179 @@
+type SeatData = {
+    proposal: ProposalRecord;
+    initialAllocation: Allocation;
+    seatHandle: SeatHandle;
+    offerArgs?: object;
+};
+/**
+ * Given an allocation, withdraw payments to create a payout
+ */
+type WithdrawPayments = (allocation: Allocation) => PaymentPKeywordRecord;
+type WithdrawFacet = {
+    withdrawPayments: (allocation: Allocation) => PaymentPKeywordRecord;
+};
+type InstanceAdminHelper = {
+    exitZoeSeatAdmin: (zoeSeatAdmin: ZoeSeatAdmin) => void;
+    hasExited: (zoeSeatAdmin: ZoeSeatAdmin) => boolean;
+};
+type ZoeSeatAdminKit = {
+    userSeat: UserSeat;
+    zoeSeatAdmin: ZoeSeatAdmin;
+};
+/**
+ * Make the Zoe seat admin, user seat and a notifier
+ */
+type MakeZoeSeatAdminKit = (initialAllocation: Allocation, instanceAdminHelper: InstanceAdminHelper, proposal: ProposalRecord, withdrawFacet: WithdrawFacet, exitObj: ERef<ExitObj>, offerResult?: unknown, baggage: import('@agoric/vat-data').Baggage) => ZoeSeatAdminKit;
+type ZoeSeatAdminExit = (completion?: Completion) => void;
+type ZoeSeatAdmin = {
+    replaceAllocation: (allocation: Allocation) => void;
+    exit: ZoeSeatAdminExit;
+    /**
+     * called with the reason
+     * for calling fail on this seat, where reason is normally an instanceof Error.
+     */
+    fail: import('@agoric/swingset-vat').ShutdownWithFailure;
+    getExitSubscriber: () => Subscriber<AmountKeywordRecord>;
+};
+type HandleOfferResult = {
+    offerResultPromise: Promise<unknown>;
+    exitObj: ExitObj;
+};
+/**
+ * The seatHandle may be created in either the Zoe or ZCF vat,
+ * depending on whether the seat comes from a normal offer or a
+ * request by the contract for an "empty" seat.
+ */
+type InstanceAdmin = {
+    assertAcceptingOffers: () => void;
+    makeUserSeat: (invitationHandle: InvitationHandle, initialAllocation: Allocation, proposal: ProposalRecord, offerArgs?: object) => UserSeat;
+    makeNoEscrowSeat: MakeNoEscrowSeat;
+    getInstance: () => Instance;
+    getPublicFacet: () => object;
+    getIssuers: () => IssuerKeywordRecord;
+    getBrands: () => BrandKeywordRecord;
+    getTerms: () => object;
+    getOfferFilter: () => string[];
+    getInstallation: () => Installation;
+    exitAllSeats: (completion: Completion) => void;
+    failAllSeats: import('@agoric/swingset-vat').ShutdownWithFailure;
+    stopAcceptingOffers: () => void;
+    isBlocked: (string: string) => boolean;
+    initDelayedState: (handleOfferObj: HandleOfferObj, publicFacet: unknown) => void;
+    setOfferFilter: (strings: string[]) => void;
+};
+/**
+ * The seatHandle may be created in either the Zoe or ZCF vat,
+ * depending on whether the seat comes from a normal offer or a
+ * request by the contract for an "empty" seat.
+ */
+type HandleOfferObj = {
+    handleOffer: (invitationHandle: InvitationHandle, seatData: SeatData) => HandleOfferResult;
+};
+type ZoeInstanceAdminMakeInvitation = (invitationHandle: InvitationHandle, description: string, customDetails?: Record<string, any> | undefined, proposalShape?: Pattern) => Invitation;
+type ZoeInstanceAdmin = {
+    makeInvitation: ZoeInstanceAdminMakeInvitation;
+    saveIssuer: (issuerP: ERef<globalThis.Issuer>, keyword: Keyword) => Promise<IssuerRecord>;
+    makeZoeMint: MakeZoeMint;
+    registerFeeMint: RegisterFeeMint;
+    makeNoEscrowSeat: MakeNoEscrowSeat;
+    replaceAllocations: ReplaceAllocations;
+    exitAllSeats: (completion: Completion) => void;
+    failAllSeats: import('@agoric/swingset-vat').ShutdownWithFailure;
+    exitSeat: (seatHandle: SeatHandle, completion: Completion) => void;
+    failSeat: (seatHandle: SeatHandle, reason: Error) => void;
+    stopAcceptingOffers: () => void;
+    setOfferFilter: (strings: Array<string>) => void;
+    getOfferFilter: () => Array<string>;
+    getExitSubscriber: (seatHandle: SeatHandle) => Subscriber<AmountKeywordRecord>;
+    repairContractCompletionWatcher: () => void;
+};
+type RegisterFeeMint = (keyword: Keyword, allegedFeeMintAccess: FeeMintAccess) => ZoeMint<'nat'>;
+type WrapIssuerKitWithZoeMint = (keyword: Keyword, localIssuerKit: IssuerKit) => any;
+type MakeZoeMint = (keyword: Keyword, assetKind?: globalThis.AssetKind | undefined, displayInfo?: globalThis.AdditionalDisplayInfo | undefined, options?: Partial<{
+    elementShape: any;
+    recoverySetsOption: import("@agoric/ertp/exported").RecoverySetsOption;
+}> | undefined) => ZoeMint;
+type MakeNoEscrowSeat = (initialAllocation: Allocation, proposal: ProposalRecord, exitObj: ExitObj, seatHandle: SeatHandle) => UserSeat;
+type ReplaceAllocations = (seatHandleAllocations: SeatHandleAllocation[]) => any;
+type SeatHandleAllocation = {
+    seatHandle: SeatHandle;
+    allocation: Allocation;
+};
+type ZoeMint<K extends globalThis.AssetKind = globalThis.AssetKind> = {
+    getIssuerRecord: () => IssuerRecord<K>;
+    mintAndEscrow: (totalToMint: Amount<K>) => void;
+    /**
+     * Note that the burning is asynchronous, and so may not have happened by
+     * the time withdrawAndBurn returns. We rely on our other bookkeeping so that
+     * these assets are assumed burned elsewhere, so no one will try to access
+     * them even before they are actually burned.
+     */
+    withdrawAndBurn: (totalToBurn: Amount<K>) => void;
+};
+type ZCFRoot = {
+    startZcf: StartZcf;
+    restartContract: RestartContract;
+};
+type ExecuteContractResult = {
+    creatorFacet: object;
+    creatorInvitation?: Promise<Invitation<unknown, undefined>> | undefined;
+    publicFacet: object;
+    handleOfferObj: HandleOfferObj;
+};
+type StartZcf = (zoeInstanceAdmin: ERef<ZoeInstanceAdmin>, instanceRecordFromZoe: InstanceRecord, issuerStorageFromZoe: IssuerRecords, privateArgs?: object) => Promise<ExecuteContractResult>;
+type RestartContract = (privateArgs?: object) => Promise<ExecuteUpgradeableContractResult>;
+type MakeExitObj = (proposal: ProposalRecord, zoeSeatAdmin: ZCFSeat) => ExitObj;
+type ExitObj = {
+    exit: () => void;
+};
+type SeatHandle = Handle<'Seat'>;
+/**
+ * Get the assetKind for a brand known by Zoe
+ *
+ * To be deleted when brands have a property for assetKind
+ */
+type GetAssetKindByBrand = (brand: Brand) => AssetKind;
+type IssuerRecords = Array<IssuerRecord>;
+type MakeZCFSeat = (seatData: SeatData) => ZCFSeat;
+/**
+ * Drops all of the references in the seat-related weakStores by
+ * dropping the stores
+ */
+type DropAllReferences = () => void;
+type ZcfSeatManager = {
+    makeZCFSeat: MakeZCFSeat;
+    reallocate: Reallocate;
+    dropAllReferences: DropAllReferences;
+};
+type ZcfMintReallocator = {
+    reallocate: (zcfSeat: ZCFSeat, newAllocation: Allocation) => void;
+};
+/**
+ * The SeatManager holds the active zcfSeats and can reallocate and
+ * make new zcfSeats.
+ */
+type CreateSeatManager = (zoeInstanceAdmin: ERef<ZoeInstanceAdmin>, getAssetKindByBrand: GetAssetKindByBrand, shutdownWithFailure: import('@agoric/swingset-vat').ShutdownWithFailure, zcfBaggage: import('@agoric/vat-data').Baggage) => {
+    seatManager: ZcfSeatManager;
+    zcfMintReallocator: ZcfMintReallocator;
+};
+/**
+ * Add an issuer and its keyword to the instanceRecord for the
+ * contract instance
+ */
+type InstanceStateAddIssuer = (keyword: Keyword, issuerRecord: IssuerRecord) => void;
+type InstanceStateGetTerms = () => AnyTerms;
+type InstanceStateGetInstallation = () => Installation;
+type InstanceRecordGetIssuers = () => IssuerKeywordRecord;
+type InstanceRecordGetBrands = () => BrandKeywordRecord;
+type InstanceState = {
+    addIssuer: InstanceStateAddIssuer;
+    getInstanceRecord: GetInstanceRecord;
+    getTerms: InstanceStateGetTerms;
+    getInstallation: InstanceStateGetInstallation;
+    getIssuers: InstanceRecordGetIssuers;
+    getBrands: InstanceRecordGetBrands;
+    assertUniqueKeyword: (keyword: Keyword) => void;
+};
+type GetInstanceRecord = () => InstanceRecord;
+type IssuerStorageGetIssuerRecords = (issuers: Issuer[]) => IssuerRecords;
+//# sourceMappingURL=internal-types.d.ts.map

package/src/internal-types.d.ts.map

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

package/src/issuerRecord.d.ts

@@ -0,0 +1,3 @@
+export function makeIssuerRecord<K extends globalThis.AssetKind>(brand: globalThis.Brand<K>, issuer: globalThis.Issuer<K>, displayInfo: globalThis.DisplayInfo<K>): IssuerRecord<K>;
+export function assertFullIssuerRecord(issuerRecord: IssuerRecord): asserts issuerRecord is Required<IssuerRecord<globalThis.AssetKind>>;
+//# sourceMappingURL=issuerRecord.d.ts.map

package/src/issuerRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issuerRecord.d.ts","sourceRoot":"","sources":["issuerRecord.js"],"names":[],"mappings":"AAaO,oLAMH;AAMG,qDAHI,YAAY,wEAOtB"}

package/src/issuerStorage.d.ts

@@ -0,0 +1,14 @@
+export function provideIssuerStorage(zcfBaggage: import('@agoric/vat-data').Baggage): {
+    storeIssuerKeywordRecord: (uncleanIssuerKeywordRecord: IssuerKeywordRecord) => Promise<{
+        issuers: IssuerKeywordRecord;
+        brands: BrandKeywordRecord;
+    }>;
+    storeIssuer: (issuerP: ERef<globalThis.Issuer>) => Promise<IssuerRecord>;
+    storeIssuerRecord: (issuerRecord: IssuerRecord) => IssuerRecord;
+    getAssetKindByBrand: GetAssetKindByBrand;
+    getBrandForIssuer: <K extends globalThis.AssetKind>(issuer: globalThis.Issuer<K>) => globalThis.Brand<K>;
+    getIssuerForBrand: <K_1 extends globalThis.AssetKind>(brand: globalThis.Brand<K_1>) => globalThis.Issuer<K_1>;
+    getIssuerRecords: IssuerStorageGetIssuerRecords;
+    instantiate: (issuerRecords?: any[]) => void;
+};
+//# sourceMappingURL=issuerStorage.d.ts.map

package/src/issuerStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issuerStorage.d.ts","sourceRoot":"","sources":["issuerStorage.js"],"names":[],"mappings":"AAgBO,iDAFI,OAAO,kBAAkB,EAAE,OAAO;2DAwHhC,mBAAmB,KACjB,QAAQ;QAAE,OAAO,EAAE,mBAAmB,CAAC;QACnD,MAA4B,EAAE,kBAAkB,CAAA;KAAE,CAAC;uDAlDvC,QAAQ,YAAY,CAAC;sCAzBvB,YAAY,KACV,YAAY;;;;;;EAsI1B"}

package/src/makeHandle.d.ts

@@ -0,0 +1,4 @@
+export function defineDurableHandle<H extends string>(baggage: Baggage, handleType: H): H extends "Instance" ? () => Instance : () => Handle<H>;
+export function makeHandle<H extends string>(handleType: H): H extends "Instance" ? Instance : Handle<H>;
+import type { Baggage } from '@agoric/vat-data';
+//# sourceMappingURL=makeHandle.d.ts.map

package/src/makeHandle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeHandle.d.ts","sourceRoot":"","sources":["makeHandle.js"],"names":[],"mappings":"AAkBO,qHAFmC,QAAQ,mBAajD;AAUM,yGAKN;6BAlC0B,kBAAkB"}