@metamask/ocap-kernel/dist/store/index.d.mts

OCap kernel core components

import type { KernelDatabase, KVStore, VatStore } from "@metamask/kernel-store";
import { Logger } from "@metamask/logger";
import type { KRef, VatId } from "../types.mjs";
/**
 * Create a new KernelStore object wrapped around a raw kernel database. The
 * resulting object provides a variety of operations for accessing various
 * kernel-relevent persistent data structure abstractions on their own terms,
 * without burdening the kernel with the particular details of how they are
 * represented in storage.  It is our hope that these operations may be later
 * reimplemented on top of a more sophisticated database layer that can realize
 * them more directly (and thus, one hopes, more efficiently) without requiring
 * the kernel itself to be any the wiser.
 *
 * @param kdb - The kernel database this store is based on.
 * @param logger - The logger to use.
 * @returns A KernelStore object that maps various persistent kernel data
 * structures onto `kdb`.
 */
export declare function makeKernelStore(kdb: KernelDatabase, logger?: Logger): {
    makeVatStore: (vatID: string) => VatStore;
    deleteVat: (vatId: VatId) => void;
    clear: () => void;
    reset: () => void;
    kv: KVStore;
    addSubcluster: (config: import("../types.mjs").ClusterConfig) => import("../types.mjs").SubclusterId;
    getSubcluster: (subclusterId: import("../types.mjs").SubclusterId) => import("../types.mjs").Subcluster | undefined;
    getSubclusters: () => import("../types.mjs").Subcluster[];
    deleteSubcluster: (subclusterId: import("../types.mjs").SubclusterId) => void;
    addSubclusterVat: (subclusterId: import("../types.mjs").SubclusterId, vatId: VatId) => void;
    getSubclusterVats: (subclusterId: import("../types.mjs").SubclusterId) => VatId[];
    deleteSubclusterVat: (subclusterId: import("../types.mjs").SubclusterId, vatId: VatId) => void;
    getVatSubcluster: (vatId: VatId) => import("../types.mjs").SubclusterId;
    clearEmptySubclusters: () => void;
    removeVatFromSubcluster: (vatId: VatId) => void;
    startCrank: () => void;
    createCrankSavepoint: (name: string) => void;
    rollbackCrank: (savepoint: string) => void;
    endCrank: () => void;
    releaseAllSavepoints: () => void;
    waitForCrank: () => Promise<void>;
    pinObject: (kref: KRef) => void;
    unpinObject: (kref: KRef) => void;
    getPinnedObjects: () => KRef[];
    isObjectPinned: (kref: KRef) => boolean;
    translateRefKtoV: (vatId: VatId, kref: KRef, importIfNeeded: boolean) => import("../types.mjs").VRef;
    translateCapDataKtoV: (vatId: VatId, capdata: import("@endo/marshal").CapData<KRef>) => import("@endo/marshal").CapData<import("../types.mjs").VRef>;
    translateMessageKtoV: (vatId: VatId, message: import("../types.mjs").Message) => import("../types.mjs").Message;
    translateSyscallVtoK: (vatId: VatId, vso: import("@agoric/swingset-liveslots").VatSyscallObject) => import("@agoric/swingset-liveslots").VatSyscallObject;
    deleteEndpoint: (endpointId: import("../types.mjs").EndpointId) => void;
    getAllVatRecords: () => Generator<{
        vatID: VatId;
        vatConfig: import("../types.mjs").VatConfig;
    }>;
    getVatConfig: (vatID: VatId) => import("../types.mjs").VatConfig;
    setVatConfig: (vatID: VatId, vatConfig: import("../types.mjs").VatConfig) => void;
    deleteVatConfig: (vatID: VatId) => void;
    getVatIDs: () => VatId[];
    importsKernelSlot: (vatID: VatId, kernelSlot: KRef) => boolean;
    getImporters: (koid: KRef) => VatId[];
    getTerminatedVats: () => VatId[];
    markVatAsTerminated: (vatID: VatId) => void;
    forgetTerminatedVat: (vatID: VatId) => void;
    isVatTerminated: (vatID: VatId) => boolean;
    cleanupTerminatedVat: (vatID: VatId) => import("./types.mjs").VatCleanupWork;
    nextTerminatedVatCleanup: () => boolean;
    exportFromVat: (vatId: VatId, vref: import("../types.mjs").VRef) => KRef;
    isVatActive: (vatID: VatId) => boolean;
    addCListEntry: (endpointId: import("../types.mjs").EndpointId, kref: KRef, eref: import("../types.mjs").ERef) => void;
    hasCListEntry: (endpointId: import("../types.mjs").EndpointId, slot: string) => boolean;
    deleteCListEntry: (endpointId: import("../types.mjs").EndpointId, kref: KRef, eref: import("../types.mjs").ERef) => void;
    allocateErefForKref: (endpointId: import("../types.mjs").EndpointId, kref: KRef) => import("../types.mjs").ERef;
    erefToKref: (endpointId: import("../types.mjs").EndpointId, eref: import("../types.mjs").ERef) => KRef | undefined;
    krefToEref: (endpointId: import("../types.mjs").EndpointId, kref: KRef) => import("../types.mjs").ERef | undefined;
    forgetEref: (endpointId: import("../types.mjs").EndpointId, eref: import("../types.mjs").ERef) => void;
    forgetKref: (endpointId: import("../types.mjs").EndpointId, kref: KRef) => void;
    krefsToExistingErefs: (endpointId: import("../types.mjs").EndpointId, krefs: KRef[]) => import("../types.mjs").ERef[];
    getReachableFlag: (endpointId: import("../types.mjs").EndpointId, kref: KRef) => boolean;
    getReachableAndVatSlot: (endpointId: import("../types.mjs").EndpointId, kref: KRef) => {
        isReachable: boolean;
        vatSlot: string;
    };
    clearReachableFlag: (endpointId: import("../types.mjs").EndpointId, kref: KRef) => void;
    getGCActions: () => Set<import("../types.mjs").GCAction>;
    setGCActions: (actions: Set<import("../types.mjs").GCAction>) => void;
    addGCActions: (newActions: import("../types.mjs").GCAction[]) => void;
    scheduleReap: (vatId: VatId) => void;
    nextReapAction: () => import("../types.mjs").RunQueueItemBringOutYourDead | undefined;
    retireKernelObjects: (koids: KRef[]) => void;
    collectGarbage: () => void;
    setRevoked: (koId: KRef, revoked: boolean) => void;
    revoke: (koId: KRef) => void;
    isRevoked: (koId: KRef) => boolean;
    initKernelPromise: () => [KRef, import("../types.mjs").KernelPromise];
    getKernelPromise: (kpid: KRef) => import("../types.mjs").KernelPromise;
    deleteKernelPromise: (kpid: KRef) => void;
    getNextPromiseId: () => KRef;
    addPromiseSubscriber: (vatId: VatId, kpid: KRef) => void;
    setPromiseDecider: (kpid: KRef, vatId: VatId) => void;
    resolveKernelPromise: (kpid: KRef, rejected: boolean, value: import("@endo/marshal").CapData<KRef>) => void;
    enqueuePromiseMessage: (kpid: KRef, message: import("../types.mjs").Message) => void;
    getKernelPromiseMessageQueue: (kpid: KRef) => import("../types.mjs").Message[];
    getPromisesByDecider: (decider: VatId) => Generator<string>;
    getKpidsToRetire: (origKpid: KRef, origValue: import("@endo/marshal").CapData<KRef>) => KRef[];
    initKernelObject: (owner: import("../types.mjs").EndpointId) => KRef;
    getOwner: (koId: KRef, throwIfUnknown?: boolean) => import("../types.mjs").EndpointId | undefined;
    getRootObject: (vatId: VatId) => KRef | undefined;
    isRootObject: (kref: KRef, vatId: VatId) => boolean;
    deleteKernelObject: (koId: KRef) => void;
    getNextObjectId: () => KRef;
    getObjectRefCount: (kref: KRef) => {
        reachable: number;
        recognizable: number;
    };
    setObjectRefCount: (kref: KRef, counts: {
        reachable: number;
        recognizable: number;
    }) => void;
    getRefCount: (kref: KRef) => number;
    kernelRefExists: (kref: KRef) => boolean;
    incRefCount: (kref: KRef) => number;
    decRefCount: (kref: KRef) => number;
    incrementRefCount: (kref: KRef, tag: string, { isExport, onlyRecognizable, }?: {
        isExport?: boolean;
        onlyRecognizable?: boolean;
    }) => void;
    decrementRefCount: (kref: KRef, tag: string, { isExport, onlyRecognizable, }?: {
        isExport?: boolean;
        onlyRecognizable?: boolean;
    }) => boolean;
    getQueueLength: (queueName: string) => number;
    enqueueRun: (message: import("../types.mjs").RunQueueItem) => void;
    dequeueRun: () => import("../types.mjs").RunQueueItem | undefined;
    runQueueLength: () => number;
    getNextVatId: () => VatId;
    getNextRemoteId: () => import("../types.mjs").RemoteId;
    initEndpoint: (endpointId: import("../types.mjs").EndpointId) => void;
};
export type KernelStore = ReturnType<typeof makeKernelStore>;
//# sourceMappingURL=index.d.mts.map