web-dc-api 0.0.58 → 0.0.60

package/dist/types/implements/threaddb/db/collection.d.ts

@@ -0,0 +1,180 @@
+import { Key } from 'interface-datastore';
+import { AnySchema } from 'ajv';
+import { Ed25519PubKey } from '../../../common/dc-key/ed25519.js';
+import { ICollection, IDB, ITxn, Event } from '../core/db.js';
+import { ThreadToken } from '../core/identity.js';
+import { Query } from './query.js';
+
+/**
+ * Instance ID type
+ */
+type InstanceID = string;
+/**
+ * Index defines an index configuration
+ */
+interface Index {
+    /**
+     * Path to the field to index in dot syntax, e.g., "name.last" or "age".
+     */
+    path: string;
+    /**
+     * Unique indicates that only one instance should exist per field value.
+     */
+    unique?: boolean;
+}
+/**
+ * Collection configuration interface
+ */
+/**
+ * Index definition for collections
+ */
+interface Index {
+    path: string;
+    unique?: boolean;
+}
+/**
+ * Collection class - a group of instances sharing a schema
+ */
+declare class Collection implements ICollection {
+    readonly name: string;
+    schema: AnySchema;
+    db: IDB;
+    rawWriteValidator?: string | undefined;
+    rawReadFilter?: string | undefined;
+    private schemaValidator;
+    private vm;
+    private writeValidator;
+    readFilter: ((reader: any, instance: any) => any) | null;
+    indexes: Map<string, Index>;
+    constructor(name: string, schema: AnySchema, db: IDB, rawWriteValidator?: string | undefined, rawReadFilter?: string | undefined);
+    private compileAndLoadValidator;
+    /**
+     * Get base key for this collection
+     */
+    baseKey(): Key;
+    /**
+     * Get collection name
+     */
+    getName(): string;
+    /**
+     * Get collection schema
+     */
+    getSchema(): Uint8Array;
+    /**
+     * Get write validator
+     */
+    getWriteValidator(): Uint8Array;
+    /**
+     * Get read filter
+     */
+    getReadFilter(): Uint8Array;
+    /**
+     * Create a read transaction
+     */
+    readTxn(fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+    /**
+     * Create a write transaction
+     */
+    writeTxn(fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+    /**
+     * Find instance by ID
+     */
+    findByID(id: InstanceID, token?: ThreadToken): Promise<Object>;
+    /**
+     * Create a new instance
+     */
+    create(v: Uint8Array, token?: ThreadToken): Promise<InstanceID>;
+    /**
+     * Create multiple instances
+     */
+    createMany(vs: Uint8Array[], token?: ThreadToken): Promise<InstanceID[]>;
+    /**
+     * Delete an instance by ID
+     */
+    delete(id: InstanceID, token?: ThreadToken): Promise<void>;
+    /**
+     * Delete multiple instances by ID
+     */
+    deleteMany(ids: InstanceID[], token?: ThreadToken): Promise<void>;
+    /**
+     * Save changes to an instance
+     */
+    save(v: Uint8Array, token?: ThreadToken): Promise<void>;
+    /**
+     * Save changes to multiple instances
+     */
+    saveMany(vs: Uint8Array[], token?: ThreadToken): Promise<void>;
+    /**
+     * Verify changes to an instance
+     */
+    verify(v: Uint8Array, token?: ThreadToken): Promise<void>;
+    /**
+     * Verify changes to multiple instances
+     */
+    verifyMany(vs: Uint8Array[], token?: ThreadToken): Promise<void>;
+    /**
+     * Check if an instance exists
+     */
+    has(id: InstanceID, token?: ThreadToken): Promise<boolean>;
+    /**
+     * Check if multiple instances exist
+     */
+    hasMany(ids: InstanceID[], token?: ThreadToken): Promise<boolean>;
+    /**
+     * Find instances matching a query
+     */
+    find(q: Query, token?: ThreadToken): Promise<Object[]>;
+    /**
+     * Get instances modified since a specific time
+     */
+    modifiedSince(time: number, token?: ThreadToken): Promise<InstanceID[]>;
+    /**
+     * Validate an instance against the collection schema
+     */
+    validInstance(v: Uint8Array): void;
+    /**
+     * Validate write operations against the write validator
+     */
+    validWrite(identity: Ed25519PubKey, e: Event): Promise<void>;
+    /**
+     * Filter read operations based on the read filter
+     */
+    filterRead(identity: Ed25519PubKey | undefined, instance: Uint8Array): Promise<Uint8Array | null>;
+    /**
+     * 返回当前索引列表
+     */
+    getIndexes(): Index[];
+    /**
+     * 创建基于路径的新索引
+     * 使用点语法访问嵌套字段，例如 "name.last"
+     * 路径上的字段必须是支持的JSON Schema类型之一: string, number, integer, 或 boolean
+     * 设置unique为true可以在该路径上创建唯一性约束
+     * 添加索引将覆盖任何已存在的重叠索引值
+     * 注意: 这目前不会构建索引。如果在添加新索引之前已添加了项目，它们不会被事后索引。
+     */
+    addIndex(index: Index, token?: ThreadToken): Promise<void>;
+    /**
+     * 删除指定路径的索引
+     */
+    dropIndex(path: string): Promise<void>;
+    /**
+     * 持久化当前索引
+     */
+    saveIndexes(): Promise<void>;
+    /**
+     * 向索引添加条目
+     */
+    indexAdd(txn: any, key: Key, data: Uint8Array): Promise<void>;
+    /**
+     * 从索引中移除条目
+     * 确保传入的是旧记录的数据，而非新记录
+     */
+    indexDelete(txn: any, key: Key, originalData: Uint8Array): Promise<void>;
+    /**
+     * 在项目上添加或移除特定索引
+     */
+    indexUpdate(field: string, index: Index, txn: any, key: Key, input: Uint8Array, deleteOp: boolean): Promise<void>;
+}
+
+export { Collection };
+export type { Index, InstanceID };

package/dist/types/implements/threaddb/db/db.d.ts

@@ -0,0 +1,63 @@
+import { Key } from 'interface-datastore';
+import { Key as Key$1 } from '../common/key.js';
+import { App, Connector, LocalEventsBus, Net } from '../core/app.js';
+import { NewOptions, ManagedOptions, IDBInfo, ICollectionConfig, IPLDNode } from '../core/core.js';
+import { IDB, TxnDatastoreExtended, EventCodec, Event, ITxn } from '../core/db.js';
+import { IThreadRecord } from '../core/record.js';
+import { Ed25519PubKey } from '../../../common/dc-key/ed25519.js';
+import { Collection } from './collection.js';
+import { ThreadToken } from '../core/identity.js';
+import { ThreadID } from '@textile/threads-id';
+import { Dispatcher } from '../common/dispatcher.js';
+
+declare class DB implements App, IDB {
+    private name;
+    connector: Connector | null;
+    datastore: TxnDatastoreExtended;
+    dispatcher: Dispatcher | null;
+    eventcodec: EventCodec;
+    collections: Map<string, Collection>;
+    localEventsBus: LocalEventsBus | null;
+    private webLock;
+    constructor(datastore: TxnDatastoreExtended, net: Net, id: string, opts: NewOptions);
+    static newDB(store: TxnDatastoreExtended, n: Net, id: ThreadID, opts?: NewOptions): Promise<DB>;
+    /**
+     * GetDBInfo returns the addresses and key that can be used to join the DB thread.
+     * @param options Optional settings for the operation
+     * @returns Promise resolving to thread info
+     */
+    getDBInfo(options?: ManagedOptions): Promise<IDBInfo>;
+    saveName(prevName: string): Promise<void>;
+    loadName(): Promise<void>;
+    saveVerno(verno: number): Promise<void>;
+    loadVerno(): Promise<number>;
+    private initCollections;
+    upgradeCollections(configs: ICollectionConfig[]): Promise<void>;
+    newCollection(config: ICollectionConfig, forceUpdate?: boolean): Promise<Collection>;
+    saveCollection(c: Collection): Promise<void>;
+    reCreateCollections(): Promise<void>;
+    getCollection(name: string): Collection;
+    close(): Promise<void>;
+    reduce(events: Event[]): Promise<void>;
+    /**
+     * 默认索引函数
+     * 创建一个处理集合索引更新的函数
+     */
+    defaultIndexFunc(): (collection: string, key: Key, txn: any, oldData?: Uint8Array, newData?: Uint8Array) => Promise<void>;
+    private notifyStateChanged;
+    /**
+     * 通知事务事件
+     * 将事务相关的节点和令牌发送到本地事件总线
+     */
+    notifyTxnEvents(node: IPLDNode, token: ThreadToken): Promise<void>;
+    dispatch(events: Event[]): Promise<void>;
+    validateNetRecordBody(body: IPLDNode, identity: Ed25519PubKey): Promise<Error | undefined>;
+    handleNetRecord(rec: IThreadRecord, key: Key$1): Promise<Error | undefined>;
+    getNetRecordCreateTime(rec: IThreadRecord, key: Key$1): Promise<BigInt>;
+    private getBlockWithRetry;
+    readTxn(collection: Collection, fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+    private writeQueue;
+    writeTxn(collection: Collection, fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+}
+
+export { DB };

package/dist/types/implements/threaddb/db/query.d.ts

@@ -0,0 +1,140 @@
+import { InstanceID } from '../core/db.js';
+
+/**
+ * Query is a JSON-serializable query representation
+ */
+declare class Query {
+    ands: Criterion[];
+    ors: Query[];
+    sort: Sort;
+    seek: InstanceID;
+    limit: number;
+    skip: number;
+    index: string;
+    constructor();
+    /**
+     * Validate validates the entire query
+     */
+    validate(): Error | null;
+    /**
+     * And concatenates a new condition in an existing field
+     */
+    and(field: string): Criterion;
+    /**
+     * Or concatenates a new condition that is sufficient
+     * for an instance to satisfy, independent of the current Query.
+     * Has left-associativity as: (a And b) Or c
+     */
+    or(orQuery: Query): Query;
+    /**
+     * UseIndex specifies the index to use when running this query
+     */
+    useIndex(path: string): Query;
+    /**
+     * OrderBy specifies ascending order for the query results
+     */
+    orderBy(field: string): Query;
+    /**
+     * OrderByDesc specifies descending order for the query results
+     */
+    orderByDesc(field: string): Query;
+    /**
+     * OrderByID specifies ascending ID order for the query results
+     */
+    orderById(): Query;
+    /**
+     * OrderByIDDesc specifies descending ID order for the query results
+     */
+    orderByIdDesc(): Query;
+    /**
+     * SeekID seeks to the given ID before returning query results
+     */
+    seekId(id: InstanceID): Query;
+    /**
+     * LimitTo sets the maximum number of results
+     */
+    limitTo(limit: number): Query;
+    /**
+     * SkipNum skips the given number of results
+     */
+    skipNum(num: number): Query;
+    /**
+     * Match checks if the given object matches this query
+     */
+    match(v: Record<string, any>): boolean;
+}
+/**
+ * Criterion represents a restriction on a field
+ */
+declare class Criterion {
+    fieldPath: string;
+    operation: Operation;
+    value: Value;
+    private query;
+    constructor(fieldPath: string, operation?: Operation, value?: Value);
+    /**
+     * Validate validates a single query criterion
+     */
+    validate(): Error | null;
+    /**
+     * Eq is an equality operator against a field
+     */
+    eq(value: any): Query;
+    /**
+     * Ne is a not equal operator against a field
+     */
+    ne(value: any): Query;
+    /**
+     * Gt is a greater operator against a field
+     */
+    gt(value: any): Query;
+    /**
+     * Lt is a less operation against a field
+     */
+    lt(value: any): Query;
+    /**
+     * Ge is a greater or equal operator against a field
+     */
+    ge(value: any): Query;
+    /**
+     * Le is a less or equal operator against a field
+     */
+    le(value: any): Query;
+    /**
+     * Creates a criterion with the specified operation and value
+     */
+    private createCriterion;
+    /**
+     * Match checks if the given value matches this criterion
+     */
+    match(value: any): boolean;
+}
+/**
+ * Value models a single value in JSON
+ */
+declare class Value {
+    string: string | null;
+    bool: boolean | null;
+    float: number | null;
+}
+/**
+ * Sort represents a sort order on a field
+ */
+declare class Sort {
+    fieldPath: string;
+    desc: boolean;
+}
+/**
+ * Operation models comparison operators
+ */
+declare enum Operation {
+    eq = 0,// equals
+    ne = 1,// not equal to
+    gt = 2,// greater than
+    lt = 3,// less than
+    ge = 4,// greater than or equal to
+    le = 5,// less than or equal to
+    fn = 6
+}
+
+export { Criterion, Operation, Query, Sort, Value };

package/dist/types/implements/threaddb/dbclient.d.ts

@@ -0,0 +1,65 @@
+import { Client } from '../../common/dcapi.js';
+import { Multiaddr } from '@multiformats/multiaddr';
+import { NewThreadOptions } from './core/options.js';
+import { ThreadID } from '@textile/threads-id';
+import { PeerId } from '@libp2p/interface';
+import { IRecord } from './core/record.js';
+import { DcUtil } from '../../common/dcutil.js';
+import { ILogstore } from './core/logstore.js';
+import { IThreadLogInfo, SymKey, IThreadInfo } from './core/core.js';
+import { Net } from './core/app.js';
+import { ThreadToken } from './core/identity.js';
+import { PeerRecords } from './net/define.js';
+
+declare class DBClient {
+    client: Client;
+    dc: DcUtil;
+    logstore: ILogstore;
+    net: Net;
+    constructor(dcClient: Client, dcUtil: DcUtil, net: Net, logstore: ILogstore);
+    requestThreadID(peerAddr?: Multiaddr): Promise<string>;
+    createThread(tid: string, opts: NewThreadOptions): Promise<string>;
+    pushRecordToPeer(tid: ThreadID, lid: PeerId, rec: IRecord, counter: number): Promise<void>;
+    /**
+     * 与对等点交换边缘（状态信息）
+     * @param threadIds threadID数组
+     * @returns 无返回值
+     */
+    exchangeEdges(threadIds: ThreadID[]): Promise<void>;
+    /**
+     * 获取threaddb 的本地边缘值（地址和头部）
+     * 边缘值用于确定是否需要从远程对等点获取更新
+     *
+     * @param tid threaddb ID
+     * @returns 地址边缘值和头部边缘值的对象
+     * @throws 错误，包括特定的"No address edge"和"No heads edge"错误
+     */
+    private localEdges;
+    /**
+     * 调度日志更新
+     * @param tid threaddb ID
+     */
+    scheduleUpdateLogs(tid: ThreadID): Promise<void>;
+    /**
+     * 调度记录更新
+     * @param tid threaddb ID
+     */
+    private scheduleUpdateRecords;
+    /**
+     * 构建获取记录的请求
+     */
+    private buildGetRecordsRequest;
+    /**
+     * 获取threaddb 中的日志
+     * @param tid threaddb ID
+     * @param pid 对等点ID
+     * @returns 日志信息数组
+     */
+    getLogs(tid: ThreadID): Promise<IThreadLogInfo[]>;
+    getRecordsFromPeer(req: any, serviceKey: SymKey): Promise<Record<string, PeerRecords>>;
+    getThreadFromPeer(id: ThreadID, peerId: PeerId, options?: {
+        token?: ThreadToken;
+    }): Promise<IThreadInfo>;
+}
+
+export { DBClient };

package/dist/types/implements/threaddb/dbmanager.d.ts

@@ -0,0 +1,199 @@
+import { PeerId } from '@libp2p/interface';
+import { Multiaddr } from '@multiformats/multiaddr';
+import { ThreadID } from '@textile/threads-id';
+import { DB } from './db/db.js';
+import { Net } from './core/app.js';
+import { ChainUtil } from '../../common/chain.js';
+import { Ed25519PrivKey } from '../../common/dc-key/ed25519.js';
+import { Key, SymmetricKey } from './common/key.js';
+import { NewOptions, ThreadMuliaddr, Context, ThreadInfo, ICollectionConfig, ManagedOptions, IDBInfo } from './core/core.js';
+import { TxnDatastoreExtended } from './core/db.js';
+import { DCConnectInfo } from '../../common/types/types.js';
+import { DcUtil } from '../../common/dcutil.js';
+import { LineReader } from './common/lineReader.js';
+import { DCContext } from '../../interfaces/DCContext.js';
+
+declare class DBManager {
+    private store;
+    private network;
+    private dc;
+    private connectedDc;
+    private opts;
+    private dbs;
+    private lock;
+    chainUtil: ChainUtil;
+    private storagePrefix;
+    private context;
+    constructor(store: TxnDatastoreExtended, //实际上是一个LevelDatastore实例,用levelDatastoreAdapter包装
+    network: Net, dc: DcUtil, connectedDc: DCConnectInfo, opts: NewOptions | undefined, chainUtil: ChainUtil, storagePrefix: string, context: DCContext);
+    loadDbs(): Promise<void>;
+    /**
+    * Gets the log key for a thread. If it doesn't exist, creates a new one.
+    * @param tid Thread ID
+    * @returns Promise resolving to the private key
+    * @throws Error if key operations fail
+    */
+    getLogKey(tid: ThreadID): Promise<Ed25519PrivKey>;
+    /**
+    * Creates a new log key
+    * @private
+    */
+    private newLogKey;
+    /**
+     * FromAddr returns ID from a multiaddress if present.
+     * @param addr Multiaddr instance
+     * @returns ID instance
+     */
+    static fromAddr(addr: Multiaddr): ThreadID;
+    /**
+     * ToAddr returns ID wrapped as a multiaddress.
+     * @returns Multiaddr instance
+     */
+    toAddr(): Multiaddr;
+    newDBFromAddr(addr: ThreadMuliaddr, key: Key, opts?: NewOptions): Promise<DB>;
+    private pullThreadBackground;
+    /**
+     * Preloads a database from DC network to local
+     * Generally happens when a new device first logs in to sync previously created databases
+     *
+     * @param threadid Thread ID string
+     * @param fid Content ID string of the file to preload
+     * @param dbname Database name
+     * @param dbAddr Database address string
+     * @param b32Rk Base32-encoded read key
+     * @param b32Sk Base32-encoded secret key
+     * @param block Whether to block until syncing is complete
+     * @param jsonCollections JSON string of collection configurations
+     * @returns Promise that resolves when preloading is complete
+     */
+    preloadDBFromDC(threadid: string, fid: string, dbname: string, dbAddr: string, b32Rk: string, b32Sk: string, block: boolean, jsonCollections: string): Promise<void>;
+    /**
+     * 从读取器预加载数据库
+     * @param ctx 上下文
+     * @param ioReader 数据流读取器
+     * @param addr 线程地址
+     * @param key 线程密钥
+     * @param opts 管理选项
+     */
+    preloadDBFromReader(ctx: Context, ioReader: ReadableStream<Uint8Array>, addr: ThreadMuliaddr, key: Key, opts?: NewOptions): Promise<void>;
+    /**
+     * Browser-compatible version to export DB to file
+     * @param ctx Context
+     * @param id ThreadID
+     * @param fileName Suggested file name for download
+     * @param readKey Optional encryption key
+     * @returns Promise resolving to ThreadInfo
+     */
+    exportDBToFile(ctx: Context, id: ThreadID, fileName: string, readKey?: SymmetricKey): Promise<ThreadInfo>;
+    /**
+     * 从读取器导入数据库状态
+     * @param id 线程ID
+     * @param reader 可读流读取器
+     * @param readKey 用于解密的对称密钥
+     */
+    importDBStateFromReader(id: ThreadID, lineReader: LineReader, readKey: SymmetricKey): Promise<void>;
+    /**
+     * wrapDB 复制管理器的基本配置，
+     * 使用 ID 前缀包装数据存储，
+     * 并将指定的集合配置与基本配置合并
+     */
+    wrapDB(store: TxnDatastoreExtended, id: ThreadID, base: NewOptions, name: string, collections: ICollectionConfig[]): Promise<[TxnDatastoreExtended, NewOptions, Error | null]>;
+    listDBs(): Promise<Map<ThreadID, DB>>;
+    ifSyncDBToDCSuccess(tId: string): Promise<boolean>;
+    private compareThreadSync;
+    ifDbInitSuccess(tid: ThreadID): Promise<boolean>;
+    syncDBFromDC(ctx: Context, threadid: string, dbname: string, dbAddr: string, b32Rk: string, b32Sk: string, block: boolean, collectionInfos: ICollectionConfig[]): Promise<Error | null>;
+    getDBRecordsCount(threadid: string): Promise<number>;
+    addLogToThread(ctx: Context, id: ThreadID, lid: PeerId): Promise<void>;
+    addLogToThreadStart(ctx: Context, id: ThreadID, lid: PeerId): Promise<void>;
+    newDB(dbname: string, b32Rk: string, b32Sk: string, collectionInfos: ICollectionConfig[]): Promise<[string, Error | null]>;
+    refreshDBFromDC(threadId: string): Promise<Error | null>;
+    syncDBToDC(threadId: string): Promise<Error | null>;
+    upgradeCollections(threadId: string, configs: ICollectionConfig[]): Promise<Error | null>;
+    private decodeThreadId;
+    validateThreadId(threadid: string): Promise<boolean>;
+    close(): Promise<void>;
+    /**
+     * Gets a database by ID
+     * @param ctx The context for the operation
+     * @param id The thread ID of the database
+     * @param opts Optional managed options
+     * @returns Promise resolving to the database instance
+     * @throws Error if the database cannot be found
+     */
+    getDB(id: ThreadID, opts?: ManagedOptions): Promise<DB>;
+    getDBInfo(id: ThreadID, opts?: ManagedOptions): Promise<[IDBInfo | null, Error | null]>;
+    deleteDB(id: ThreadID, deleteThreadFlag: boolean, opts?: ManagedOptions): Promise<void>;
+    private deleteThreadNamespace;
+    /**********************数据库数据操作相关**********************/
+    /**
+         * Create creates new instances of objects in a collection
+         * @param threadId Thread ID string
+         * @param collectionName Collection name
+         * @param jsonInstance JSON string representing the instance
+         * @returns Promise resolving to the created instance ID
+         * @throws Error if creation fails
+         */
+    create(threadId: string, collectionName: string, jsonInstance: string): Promise<string>;
+    /**
+         * Delete deletes an instance by ID
+         * @param threadId Thread ID string
+         * @param collectionName Collection name
+         * @param instanceID Instance ID to delete
+         * @throws Error if deletion fails
+         */
+    delete(threadId: string, collectionName: string, instanceID: string): Promise<void>;
+    /**
+     * Save updates an existing instance
+     * @param threadId Thread ID string
+     * @param collectionName Collection name
+     * @param instance JSON string representing the instance
+     * @throws Error if update fails
+     */
+    save(threadId: string, collectionName: string, instance: string): Promise<void>;
+    /**
+     * DeleteMany deletes multiple instances by their IDs
+     * @param threadId Thread ID string
+     * @param collectionName Collection name
+     * @param instanceIDs Comma-separated or JSON array of instance IDs
+     * @throws Error if deletion fails
+     */
+    deleteMany(threadId: string, collectionName: string, instanceIDs: string): Promise<void>;
+    /**
+     * Has checks if the specified instance exists
+     * @param threadId Thread ID string
+     * @param collectionName Collection name
+     * @param instanceID Instance ID to check
+     * @returns Promise resolving to a boolean indicating if instance exists
+     */
+    has(threadId: string, collectionName: string, instanceID: string): Promise<boolean>;
+    /**
+     * Find finds instances by query
+     * @param threadId Thread ID string
+     * @param collectionName Collection name
+     * @param queryString JSON string representing the query
+     * @returns Promise resolving to a JSON string with found instances
+     * @throws Error if query fails
+     */
+    find(threadId: string, collectionName: string, queryString?: string): Promise<string>;
+    /**
+     * FindByID finds an instance by ID
+     * @param threadId Thread ID string
+     * @param collectionName Collection name
+     * @param instanceID Instance ID to find
+     * @returns Promise resolving to a JSON string with found instance
+     * @throws Error if query fails
+     */
+    findByID(threadId: string, collectionName: string, instanceID: string): Promise<string>;
+    /**
+     * ModifiedSince returns instance IDs modified since the given time
+     * @param threadId Thread ID string
+     * @param collectionName Collection name
+     * @param time Unix timestamp in milliseconds
+     * @returns Promise resolving to a JSON string with instance IDs
+     * @throws Error if query fails
+     */
+    modifiedSince(threadId: string, collectionName: string, time: number): Promise<string>;
+}
+
+export { DBManager };

package/dist/types/implements/threaddb/net/define.d.ts

@@ -0,0 +1,11 @@
+import { IRecord } from '../core/record.js';
+
+/**
+ * Records with counters from a peer
+ */
+interface PeerRecords {
+    records: IRecord[];
+    counter: number;
+}
+
+export type { PeerRecords };

package/dist/types/implements/threaddb/net/grpcserver.d.ts

@@ -0,0 +1,20 @@
+import { Libp2p } from '@libp2p/interface';
+import { StreamWriter } from 'grpc-libp2p-client/dc-http2/stream';
+
+declare class DCGrpcServer {
+    private libp2p;
+    private protocol;
+    constructor(libp2p: Libp2p, protocol: string);
+    start(): void;
+    stop(): void;
+    _parseFrameHeader(buffer: Uint8Array): {
+        length: number;
+        type: number | undefined;
+        flags: number | undefined;
+        streamId: number;
+        payload: Uint8Array<ArrayBuffer>;
+    };
+    getLogs(streamId: number, request: any, writer: StreamWriter): Promise<any>;
+}
+
+export { DCGrpcServer };