web-dc-api 0.0.58 → 0.0.60

package/dist/types/implements/threaddb/core/app.d.ts

@@ -0,0 +1,77 @@
+import EventEmitter from 'eventemitter3';
+import { ThreadID } from '@textile/threads-id';
+import { IThreadRecord } from './record.js';
+import { Key } from '../common/key.js';
+import { INet, IPLDNode, ThreadInfo, SymKey, IThreadLogInfo } from './core.js';
+import { ThreadToken } from './identity.js';
+import { Ed25519PubKey } from '../../../common/dc-key/ed25519.js';
+import { PeerId } from '@libp2p/interface';
+import { Head } from './head.js';
+import { net } from '../pb/net_pb.d.js';
+import { DBClient } from '../dbclient.js';
+import { Blocks } from 'helia';
+import { AsyncMutex } from '../common/AsyncMutex.js';
+
+type PubKey = Ed25519PubKey;
+type Token = Uint8Array;
+interface App {
+    validateNetRecordBody(body: IPLDNode, identity: PubKey): Promise<Error | undefined>;
+    handleNetRecord(rec: IThreadRecord, key?: Key): Promise<Error | undefined>;
+    getNetRecordCreateTime(rec: IThreadRecord, key?: Key): Promise<BigInt>;
+}
+declare class LocalEventsBus {
+    private bus;
+    private static readonly busTimeout;
+    send(event: LocalEvent): Promise<void>;
+    listen(): LocalEventListener;
+    discard(): void;
+}
+declare class LocalEventListener {
+    private bus;
+    private handler;
+    constructor(bus: EventEmitter);
+    private onEvent;
+    discard(): void;
+}
+interface LocalEvent {
+    node: IPLDNode;
+    token: ThreadToken;
+}
+interface Net extends INet {
+    bstore: Blocks;
+    connectApp(app: App, threadId: ThreadID): Promise<Connector>;
+    createRecord(threadId: ThreadID, body: IPLDNode, options?: {
+        threadToken?: ThreadToken;
+        apiToken?: Token;
+    }): Promise<IThreadRecord>;
+    validate(id: ThreadID, token?: ThreadToken): Promise<Ed25519PubKey | undefined>;
+    exchange(id: ThreadID): Promise<void>;
+    threadOffsets(tid: ThreadID): Promise<[Record<string, Head>, PeerId[]]>;
+    buildGetRecordsRequest(tid: ThreadID, offsets: Record<string, Head>, limit: number): Promise<{
+        req: net.pb.IGetRecordsRequest;
+        serviceKey: SymKey;
+    }>;
+    updateRecordsFromPeer(tid: ThreadID, peerId: PeerId | null, client?: DBClient): Promise<void>;
+    getMutexForThread(threadId: string): AsyncMutex;
+    preLoadLogs(tid: ThreadID, logs: net.pb.Log[]): Promise<void>;
+    createExternalLogsIfNotExist(tid: ThreadID, logs: IThreadLogInfo[]): Promise<void>;
+    createExternalLogsIfNotExistForPreload(tid: ThreadID, logs: IThreadLogInfo[]): Promise<void>;
+}
+declare class Connector {
+    net: Net;
+    private app;
+    private threadInfo;
+    readonly token: Token;
+    constructor(net: Net, app: App, threadInfo: ThreadInfo);
+    get threadId(): ThreadID;
+    get threadKey(): Key | undefined;
+    createNetRecord(body: IPLDNode, token?: ThreadToken): Promise<IThreadRecord>;
+    validate(token?: ThreadToken): Promise<Error | undefined>;
+    validateNetRecordBody(body: IPLDNode, identity: PubKey): Promise<Error | undefined>;
+    handleNetRecord(rec: IThreadRecord): Promise<Error | undefined>;
+    getNetRecordCreateTime(rec: IThreadRecord): Promise<BigInt>;
+    private generateRandomBytes;
+}
+
+export { Connector, LocalEventListener, LocalEventsBus };
+export type { App, LocalEvent, Net, PubKey, Token };

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

@@ -0,0 +1,114 @@
+import { Key } from '../common/key.js';
+import { ThreadID } from '@textile/threads-id';
+import { PeerId, PrivateKey, PublicKey } from '@libp2p/interface';
+import { Multiaddr } from '@multiformats/multiaddr';
+import { Head } from './head.js';
+import { AnySchema } from 'ajv';
+import { EventCodec } from './db.js';
+import { CID } from 'multiformats/cid';
+import { Link } from 'multiformats/link';
+import { ThreadToken } from './identity.js';
+import { Ed25519PrivKey, Ed25519PubKey } from '../../../common/dc-key/ed25519.js';
+import { net } from '../pb/net_pb.d.js';
+
+interface Context {
+    signal?: AbortSignal | undefined;
+    deadline?: Date | undefined;
+}
+interface IPLDNode {
+    cid(): CID;
+    links(): Link[];
+    size(): number;
+    data(): Uint8Array;
+}
+interface INet {
+    createThread(id: ThreadID, options: {
+        token: ThreadToken;
+        logKey?: Ed25519PrivKey | Ed25519PubKey;
+        threadKey?: Key;
+    }): Promise<ThreadInfo>;
+    addThread(addr: ThreadMuliaddr, options: {
+        token?: ThreadToken | undefined;
+        logKey?: Ed25519PrivKey | Ed25519PubKey | undefined;
+        threadKey?: Key | undefined;
+    }): Promise<ThreadInfo>;
+    getThread(id: ThreadID, ...opts: any[]): Promise<ThreadInfo>;
+    getThreadFromPeer(id: ThreadID, peer: PeerId, options: {
+        token?: ThreadToken;
+    }): Promise<ThreadInfo>;
+    deleteThread(id: ThreadID, ...opts: any[]): Promise<void>;
+    pullThread(id: ThreadID, timeout: number, ...opts: any[]): Promise<void>;
+    getPbLogs(id: ThreadID): Promise<[net.pb.ILog[], IThreadInfo]>;
+}
+interface ICollectionConfig {
+    name: string;
+    schema: AnySchema;
+    indexes?: Index[];
+    writeValidator?: string;
+    readFilter?: string;
+}
+interface Index {
+    path: string;
+    unique: boolean;
+}
+declare class NewOptions {
+    name?: string | undefined;
+    collections?: ICollectionConfig[] | undefined;
+    eventCodec?: EventCodec | undefined;
+    debug?: boolean | undefined;
+    key?: Key | undefined;
+    logKey?: Ed25519PrivKey | Ed25519PubKey | undefined;
+    block?: boolean | undefined;
+    token?: ThreadToken | undefined;
+    constructor(init?: Partial<NewOptions>);
+}
+interface ManagedOptions {
+    name: string;
+    key: Key;
+    logKey: Ed25519PrivKey | Ed25519PubKey;
+    token?: ThreadToken;
+    collections: ICollectionConfig[];
+    block: boolean;
+}
+interface SymKey {
+    key: CryptoKey;
+    raw: Uint8Array;
+}
+declare class ThreadMuliaddr {
+    addr: Multiaddr;
+    id: ThreadID;
+    constructor(addr: Multiaddr, id: ThreadID);
+    getMultiaddrString(): string;
+}
+interface IThreadInfo {
+    id: ThreadID;
+    key: Key | undefined;
+    logs: IThreadLogInfo[];
+    addrs: ThreadMuliaddr[];
+    getFirstPrivKeyLog(): IThreadLogInfo | undefined;
+}
+interface IDBInfo {
+    id: string;
+    name: string;
+    addrs: string[];
+    key: string | undefined;
+}
+declare class ThreadInfo implements IThreadInfo {
+    id: ThreadID;
+    logs: IThreadLogInfo[];
+    addrs: ThreadMuliaddr[];
+    key: Key | undefined;
+    constructor(id: ThreadID, logs: IThreadLogInfo[], addrs: ThreadMuliaddr[], key?: Key);
+    getFirstPrivKeyLog(): IThreadLogInfo | undefined;
+}
+interface IThreadLogInfo {
+    id: PeerId;
+    privKey?: PrivateKey;
+    pubKey?: PublicKey;
+    addrs: Multiaddr[];
+    managed: boolean;
+    head?: Head;
+}
+
+export { NewOptions, ThreadInfo, ThreadMuliaddr };
+export type { Context, ICollectionConfig, IDBInfo, INet, IPLDNode, IThreadInfo, IThreadLogInfo, Index, ManagedOptions, SymKey };

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

@@ -0,0 +1,161 @@
+import { Datastore, Key, Query, Batch } from 'interface-datastore';
+import { IPLDNode } from './core.js';
+import { ThreadToken } from './identity.js';
+import { Ed25519PubKey } from '../../../common/dc-key/ed25519.js';
+import { Connector, LocalEventsBus } from './app.js';
+import { Dispatcher } from '../common/dispatcher.js';
+
+type InstanceID = string;
+declare enum CoreActionType {
+    Create = 0,
+    Save = 1,
+    Delete = 2
+}
+/**
+ * Transaction class for collections
+ */
+interface ITxn {
+    /**
+     * Create new instances
+     */
+    create(...newInstances: Uint8Array[]): Promise<InstanceID[]>;
+    /**
+     * Verify instance changes without saving them
+     */
+    verify(...updated: Uint8Array[]): Promise<void>;
+    /**
+     * Save instance changes
+     */
+    save(...updated: Uint8Array[]): Promise<void>;
+    /**
+     * Delete instances
+     */
+    delete(...ids: InstanceID[]): Promise<void>;
+    /**
+     * Check if instances exist
+     */
+    has(...ids: InstanceID[]): Promise<boolean>;
+    /**
+     * Find instance by ID
+     */
+    findByID(id: InstanceID): Promise<Object>;
+    /**
+     * Find instances matching a query
+     */
+    find(q?: Query): Promise<Object[]>;
+    /**
+   * Get instances modified since a specific time
+   *
+   * The _mod field tracks modified instances, but not those that have been deleted, so we need
+   * to query the dispatcher for all (unique) instances in this collection that have been modified
+   * at all since `time`.
+   */
+    modifiedSince(time: number): Promise<InstanceID[]>;
+    /**
+     * Commit the transaction
+     */
+    commit(): Promise<void>;
+    /**
+     * Discard the transaction
+     */
+    discard(): void;
+    /**
+     * Refresh collection reference
+     */
+    refreshCollection(): void;
+}
+interface ICollection {
+    baseKey(): Key;
+    getName(): string;
+    getSchema(): Uint8Array;
+    getWriteValidator(): Uint8Array;
+    getReadFilter(): Uint8Array;
+    readTxn(fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+    writeTxn(fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+    findByID(id: InstanceID, token?: ThreadToken): Promise<Object>;
+    create(v: Uint8Array, token?: ThreadToken): Promise<InstanceID>;
+    createMany(vs: Uint8Array[], token?: ThreadToken): Promise<InstanceID[]>;
+    delete(id: InstanceID, token?: ThreadToken): Promise<void>;
+    deleteMany(ids: InstanceID[], token?: ThreadToken): Promise<void>;
+    save(v: Uint8Array, token?: ThreadToken): Promise<void>;
+    saveMany(vs: Uint8Array[], token?: ThreadToken): Promise<void>;
+    verify(v: Uint8Array, token?: ThreadToken): Promise<void>;
+    verifyMany(vs: Uint8Array[], token?: ThreadToken): Promise<void>;
+    has(id: InstanceID, token?: ThreadToken): Promise<boolean>;
+    hasMany(ids: InstanceID[], token?: ThreadToken): Promise<boolean>;
+    find(q: Query, token?: ThreadToken): Promise<Object[]>;
+    modifiedSince(time: number, token?: ThreadToken): Promise<InstanceID[]>;
+    validInstance(v: Uint8Array): void;
+    validWrite(identity: Ed25519PubKey, e: Event): Promise<void>;
+    filterRead(identity: Ed25519PubKey, instance: Uint8Array): Promise<Uint8Array | null>;
+}
+interface IDB {
+    datastore: TxnDatastoreExtended;
+    connector: Connector | null;
+    dispatcher: Dispatcher | null;
+    eventcodec: EventCodec;
+    localEventsBus: LocalEventsBus | null;
+    collections: Map<string, ICollection>;
+    readTxn(collection: ICollection, fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+    writeTxn(collection: ICollection, fn: (txn: ITxn) => Promise<void>, token?: ThreadToken): Promise<void>;
+    notifyTxnEvents(node: IPLDNode, token?: ThreadToken): Promise<void>;
+}
+interface Event<T = any> {
+    /** 事件时间戳 (Unix纳秒时间戳) */
+    readonly timestamp: BigInt;
+    /** 关联的实例ID */
+    readonly instanceID: InstanceID;
+    /** 所属集合名称 */
+    readonly collection: string;
+    /** 事件负载数据 */
+    readonly payload: T;
+    /** 序列化为Uint8Array */
+    marshal(): Promise<Uint8Array>;
+}
+interface QueryResult {
+    key: string;
+    value: Uint8Array;
+    size?: number;
+}
+interface QueryExt extends Query {
+    seekPrefix?: string;
+}
+interface Transaction {
+    put(key: Key, value: Uint8Array): Promise<Key>;
+    delete(key: Key): Promise<void>;
+    get(key: Key): Promise<Uint8Array | undefined>;
+    has(key: Key): Promise<boolean>;
+    commit(): Promise<void>;
+    discard(): void;
+    query(q: Query): AsyncIterable<QueryResult>;
+    queryExtended(q: QueryExt): AsyncIterable<QueryResult>;
+}
+interface DatastoreExtensions {
+    newTransactionExtended(readOnly: boolean): Promise<Transaction>;
+    queryExtended(q: QueryExt): AsyncIterable<QueryResult>;
+}
+interface TxnDatastoreExtended extends Datastore, DatastoreExtensions {
+    batch(): Batch;
+    newTransactionExtended(readOnly: boolean): Promise<Transaction>;
+}
+type IndexFunc = (collection: string, key: Key, txn: Transaction, oldData?: Uint8Array, newData?: Uint8Array) => Promise<void>;
+interface Action {
+    type: CoreActionType;
+    instanceID: InstanceID;
+    collectionName: string;
+    previous?: Uint8Array;
+    current?: Uint8Array;
+}
+interface ReduceAction {
+    type: CoreActionType;
+    collection: string;
+    instanceID: InstanceID;
+}
+interface EventCodec {
+    reduce(events: Event[], store: TxnDatastoreExtended, baseKey: Key, indexFn: IndexFunc): Promise<ReduceAction[]>;
+    create(actions: Action[]): Promise<[Event[], IPLDNode]>;
+    eventsFromBytes(data: Uint8Array): Promise<Event[]>;
+}
+
+export { CoreActionType };
+export type { Action, Event, EventCodec, ICollection, IDB, ITxn, IndexFunc, InstanceID, QueryExt, QueryResult, ReduceAction, Transaction, TxnDatastoreExtended };

package/dist/types/implements/threaddb/core/head.d.ts

@@ -0,0 +1,10 @@
+import { CID } from 'multiformats/cid';
+
+interface Head {
+    /** 使用multiformats的CID类型表示IPFS内容标识符 */
+    id?: CID;
+    /** 使用number表示计数器（注意JS的Number精度限制） */
+    counter: number;
+}
+
+export type { Head };

package/dist/types/implements/threaddb/core/identity.d.ts

@@ -0,0 +1,31 @@
+import { Ed25519PubKey, Ed25519PrivKey } from '../../../common/dc-key/ed25519.js';
+import { Ed25519PrivateKey } from '@libp2p/interface';
+
+interface Identity {
+    sign(data: Uint8Array): Promise<Uint8Array>;
+    getPublic(): Ed25519PubKey;
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+    equals(other: Identity): boolean;
+}
+declare class Ed25519Identity implements Identity {
+    readonly privateKey: Ed25519PrivKey;
+    readonly publicKey: Ed25519PubKey;
+    private constructor();
+    static create(): Promise<Ed25519Identity>;
+    sign(data: Uint8Array): Promise<Uint8Array>;
+    getPublic(): Ed25519PubKey;
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+    equals(other: Identity): boolean;
+}
+declare class ThreadToken {
+    readonly value: string;
+    constructor(value: string);
+    static issue(issuer: Ed25519Identity, pubKey: Ed25519PubKey): Promise<ThreadToken>;
+    pubKey(): Promise<Ed25519PubKey | undefined>;
+    validate(issuerPrivateKey: Ed25519PrivateKey): Promise<Ed25519PubKey | undefined>;
+    private parsePubKey;
+    get defined(): boolean;
+}
+
+export { Ed25519Identity, ThreadToken };
+export type { Identity };

package/dist/types/implements/threaddb/core/logstore.d.ts

@@ -0,0 +1,103 @@
+import { ThreadID } from '@textile/threads-id';
+import { PeerId, PublicKey, PrivateKey } from '@libp2p/interface';
+import { SymKey, IThreadInfo, IThreadLogInfo } from './core.js';
+import { Multiaddr } from '@multiformats/multiaddr';
+import { Head } from './head.js';
+
+interface IThreadMetadata {
+    getInt64(t: ThreadID, key: string): Promise<number | null>;
+    putInt64(t: ThreadID, key: string, val: number): Promise<void>;
+    getString(t: ThreadID, key: string): Promise<string | null>;
+    putString(t: ThreadID, key: string, val: string): Promise<void>;
+    getBool(t: ThreadID, key: string): Promise<boolean | null>;
+    putBool(t: ThreadID, key: string, val: boolean): Promise<void>;
+    getBytes(t: ThreadID, key: string): Promise<Uint8Array | null>;
+    putBytes(t: ThreadID, key: string, val: Uint8Array): Promise<void>;
+    clearMetadata(t: ThreadID): Promise<void>;
+    dumpMeta(): Promise<DumpMetadata>;
+    restoreMeta(book: DumpMetadata): Promise<void>;
+}
+interface KeyBook {
+    pubKey(threadId: ThreadID, peerId: PeerId): Promise<PublicKey | undefined>;
+    addPubKey(threadId: ThreadID, peerId: PeerId, key: PublicKey): Promise<void>;
+    privKey(threadId: ThreadID, peerId: PeerId): Promise<PrivateKey | null>;
+    addPrivKey(threadId: ThreadID, peerId: PeerId, key: PrivateKey): Promise<void>;
+    readKey(threadId: ThreadID): Promise<SymKey | undefined>;
+    addReadKey(threadId: ThreadID, key: SymKey): Promise<void>;
+    serviceKey(threadId: ThreadID): Promise<SymKey | undefined>;
+    addServiceKey(threadId: ThreadID, key: SymKey): Promise<void>;
+    clearKeys(threadId: ThreadID): Promise<void>;
+    clearLogKeys(threadId: ThreadID, peerId: PeerId): Promise<void>;
+    logsWithKeys(threadId: ThreadID): Promise<PeerId[]>;
+    threadsFromKeys(): Promise<ThreadID[]>;
+    dumpKeys(): Promise<DumpKeyBook>;
+    restoreKeys(book: DumpKeyBook): Promise<void>;
+}
+interface AddrBook {
+    addAddr(threadId: ThreadID, peerId: PeerId, addr: Multiaddr, ttl: number): Promise<void>;
+    addAddrs(threadId: ThreadID, peerId: PeerId, addrs: Multiaddr[], ttl: number): Promise<void>;
+    setAddr(threadId: ThreadID, peerId: PeerId, addr: Multiaddr, ttl: number): Promise<void>;
+    setAddrs(threadId: ThreadID, peerId: PeerId, addrs: Multiaddr[], ttl: number): Promise<void>;
+    updateAddrs(threadId: ThreadID, peerId: PeerId, oldTTL: number, newTTL: number): Promise<void>;
+    addrs(threadId: ThreadID, peerId: PeerId): Promise<Multiaddr[]>;
+    clearAddrs(threadId: ThreadID, peerId: PeerId): Promise<void>;
+    logsWithAddrs(threadId: ThreadID): Promise<PeerId[]>;
+    threadsFromAddrs(): Promise<ThreadID[]>;
+    addrsEdge(threadId: ThreadID): Promise<number>;
+    dumpAddrs(): Promise<DumpAddrBook>;
+    restoreAddrs(book: DumpAddrBook): Promise<void>;
+}
+interface HeadBook {
+    addHead(threadId: ThreadID, peerId: PeerId, head: Head): Promise<void>;
+    addHeads(threadId: ThreadID, peerId: PeerId, heads: Head[]): Promise<void>;
+    setHead(threadId: ThreadID, peerId: PeerId, head: Head): Promise<void>;
+    setHeads(threadId: ThreadID, peerId: PeerId, heads: Head[]): Promise<void>;
+    heads(threadId: ThreadID, peerId: PeerId): Promise<Head[]>;
+    clearHeads(threadId: ThreadID, peerId: PeerId): Promise<void>;
+    headsEdge(threadId: ThreadID): Promise<number>;
+    dumpHeads(): Promise<DumpHeadBook>;
+    restoreHeads(book: DumpHeadBook): Promise<void>;
+}
+interface ILogstore {
+    metadata: IThreadMetadata;
+    keyBook: KeyBook;
+    addrBook: AddrBook;
+    headBook: HeadBook;
+    close(): Promise<void>;
+    threads(): Promise<ThreadID[]>;
+    addThread(info: IThreadInfo): Promise<void>;
+    getThread(threadId: ThreadID): Promise<IThreadInfo>;
+    deleteThread(threadId: ThreadID): Promise<void>;
+    addLog(threadId: ThreadID, logInfo: IThreadLogInfo): Promise<void>;
+    getLog(threadId: ThreadID, peerId: PeerId): Promise<IThreadLogInfo>;
+    getManagedLogs(threadId: ThreadID): Promise<IThreadLogInfo[]>;
+    deleteLog(threadId: ThreadID, peerId: PeerId): Promise<void>;
+}
+interface ExpiredAddress {
+    addr: Multiaddr;
+    expires: Date;
+}
+interface DumpHeadBook {
+    data: Record<string, Record<string, Head[]>>;
+}
+interface DumpAddrBook {
+    data: Record<string, Record<string, ExpiredAddress[]>>;
+}
+interface DumpKeyBook {
+    data: {
+        public: Record<string, Record<string, PublicKey>>;
+        private: Record<string, Record<string, PrivateKey>>;
+        read: Record<string, Uint8Array>;
+        service: Record<string, Uint8Array>;
+    };
+}
+interface DumpMetadata {
+    data: {
+        int64: Record<string, Record<string, number>>;
+        bool: Record<string, Record<string, boolean>>;
+        string: Record<string, Record<string, string>>;
+        bytes: Record<string, Record<string, Uint8Array>>;
+    };
+}
+
+export type { AddrBook, DumpAddrBook, DumpHeadBook, DumpKeyBook, DumpMetadata, ExpiredAddress, HeadBook, ILogstore, IThreadMetadata, KeyBook };

package/dist/types/implements/threaddb/core/options.d.ts

@@ -0,0 +1,15 @@
+import { Key, LogKey } from '../common/key.js';
+import { Ed25519PubKey } from '../../../common/dc-key/ed25519.js';
+import { ThreadToken } from './identity.js';
+
+type NewThreadOptions = {
+    threadKey?: Key;
+    logKey?: LogKey;
+    token: ThreadToken;
+    pubkey?: Ed25519PubKey;
+    blockHeight: number;
+    signature: Uint8Array;
+    vaccount?: Ed25519PubKey;
+};
+
+export type { NewThreadOptions };

package/dist/types/implements/threaddb/core/record.d.ts

@@ -0,0 +1,32 @@
+import { CID } from 'multiformats/cid';
+import { ThreadID } from '@textile/threads-id';
+import { PeerId } from '@libp2p/interface';
+import { PublicKey } from '@libp2p/interface-keys';
+import { IPLDNode } from './core.js';
+import { Blocks } from 'helia';
+
+type Signature = Uint8Array;
+interface IRecord extends IPLDNode {
+    /** 获取内部区块的 CID */
+    blockID: () => CID;
+    /** 异步加载内部区块 */
+    getBlock: (bstore: Blocks) => Promise<IPLDNode>;
+    /** 前一个记录的 CID */
+    prevID: () => CID | undefined;
+    /** 记录的数字签名 */
+    sig: () => Signature;
+    /** 作者的原始公钥字节 */
+    pubKey: () => Uint8Array;
+    /** 验证签名有效性 */
+    verify: (key: PublicKey) => Promise<Error | undefined>;
+}
+interface IThreadRecord {
+    /** 获取底层记录对象 */
+    value: () => IRecord;
+    /** 所属线程的标识符 */
+    threadID: () => ThreadID;
+    /** 日志来源的对等节点ID */
+    logID: () => PeerId;
+}
+
+export type { IRecord, IThreadRecord, Signature };