@ceramicnetwork/core/lib/dispatcher.d.ts

Typescript implementation of the Ceramic protocol

import { CID } from 'multiformats/cid';
import { DiagnosticsLogger, IpfsApi, ServiceLogger, IpfsNodeStatus } from '@ceramicnetwork/common';
import { StreamID } from '@ceramicnetwork/streamid';
import { Repository } from './state-management/repository.js';
import { PubsubMessage, QueryMessage, ResponseMessage, UpdateMessage } from './pubsub/pubsub-message.js';
import { Subscription } from 'rxjs';
import { MessageBus } from './pubsub/message-bus.js';
import { TaskQueue } from './ancillary/task-queue.js';
import type { ShutdownSignal } from './shutdown-signal.js';
import { CarBlock, type CAR } from 'cartonne';
import { IPLDRecordsCache } from './store/ipld-records-cache.js';
import { IReconApi } from './recon.js';
export declare class CommitSizeError extends Error {
    constructor(cid: CID | string, size: number);
}
export declare class Dispatcher {
    readonly _ipfs: IpfsApi;
    private readonly topic;
    readonly repository: Repository;
    private readonly _logger;
    private readonly _pubsubLogger;
    private readonly _shutdownSignal;
    private readonly recon;
    readonly tasks: TaskQueue;
    readonly messageBus: MessageBus;
    readonly ipldCache: IPLDRecordsCache;
    private readonly pubsubCache;
    private readonly carFactory;
    private readonly _ipfsTimeout;
    readonly enableSync: boolean;
    constructor(_ipfs: IpfsApi, topic: string, repository: Repository, _logger: DiagnosticsLogger, _pubsubLogger: ServiceLogger, _shutdownSignal: ShutdownSignal, enableSync: boolean, maxQueriesPerSecond: number, recon: IReconApi, tasks?: TaskQueue);
    init(): Promise<void>;
    get shutdownSignal(): ShutdownSignal;
    ipfsNodeStatus(): Promise<IpfsNodeStatus>;
    storeRecord(record: Record<string, unknown>): Promise<CID>;
    getIpfsBlock(cid: CID): Promise<CarBlock>;
    importCAR(car: CAR, streamId: StreamID): Promise<void>;
    _createCAR(data: any): CAR;
    storeInitEvent(data: any, streamType: number): Promise<CID>;
    storeEvent(data: any, streamId: StreamID): Promise<CID>;
    retrieveCommit(cid: CID | string, streamId?: StreamID): Promise<any>;
    retrieveFromIPFS(cid: CID | string, path?: string): Promise<any>;
    cidExistsInLocalIPFSStore(cid: CID | string): Promise<boolean>;
    getFromIpfs(cid: CID | string, path?: string): Promise<any>;
    publishTip(streamId: StreamID, tip: CID, model?: StreamID): Subscription;
    handleMessage(message: PubsubMessage): Promise<void>;
    _handleTip(tip: CID, streamId: StreamID, model?: StreamID): Promise<void>;
    _handleUpdateMessage(message: UpdateMessage): Promise<void>;
    _handleQueryMessage(message: QueryMessage): Promise<void>;
    _handleResponseMessage(message: ResponseMessage): Promise<void>;
    close(): Promise<void>;
    private publish;
}
//# sourceMappingURL=dispatcher.d.ts.map