web-dc-api 0.1.4 → 0.1.6

package/lib/implements/threaddb/lsstoreds/keybook.ts

@@ -1,297 +0,0 @@
-import { Datastore, Key,Query } from 'interface-datastore'  
-import { SymKey } from '../core/core' 
-import { peerIdFromPrivateKey, peerIdFromPublicKey } from '@libp2p/peer-id'  
-import { keys } from '@libp2p/crypto'  
-import { base32 } from 'multiformats/bases/base32'  
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'  
-import { DumpKeyBook,KeyBook} from '../core/logstore'
-import { ThreadID } from '@textile/threads-id';
-import type { PeerId,PrivateKey,PublicKey } from "@libp2p/interface";
-import {uniqueLogIds,uniqueThreadIds,AllowEmptyRestore,dsLogKey,dsThreadKey } from './global'
-import { SymmetricKey } from '../common/key';
-import { symKeyFromBytes } from '../../../common/dc-key/keyManager';
-import { publicKeyFromRaw ,privateKeyFromRaw} from '@libp2p/crypto/keys'
-
-
-
-
-// 键路径构建工具  
-const KB_BASE = new Key('/thread/keys')  
-const PUB_SUFFIX = new Key('/pub')  
-const PRIV_SUFFIX = new Key('/priv')  
-const READ_SUFFIX = new Key('/read')  
-const SERVICE_SUFFIX = new Key('/service')  
-
-class DsKeyBook implements KeyBook {  
-  private ds: Datastore  
-
-  constructor(store: Datastore) {  
-    this.ds = store  
-  }  
- 
- 
-
-  async pubKey(t: ThreadID, p: PeerId): Promise<PublicKey|undefined> {  
-    const key = dsLogKey(t, p, KB_BASE).child(PUB_SUFFIX)  
-    
-    try {  
-      const value = await this.ds.get(key)  
-      return keys.publicKeyFromRaw(value)  
-    } catch (err) {  
-      if ((err as { code?: string }).code === 'ERR_NOT_FOUND') return   
-      throw new Error(`Error getting public key: ${(err as Error).message}`)  
-    }  
-  }  
-
-  async addPubKey(t: ThreadID, p: PeerId, pk: PublicKey): Promise<void> {  
-    if (!pk) throw new Error('Public key is null')  
-    
-    const peerId = peerIdFromPublicKey(pk)  
-    if (!peerId.equals(p)) {  
-      throw new Error("Log ID doesn't match provided public key")  
-    }  
-
-    const value = pk.raw
-    const key = dsLogKey(t, p, KB_BASE).child(PUB_SUFFIX)  
-    await this.ds.put(key, value)  
-  }  
-
-  async privKey(t: ThreadID, p: PeerId): Promise<PrivateKey | null> {  
-    const key = dsLogKey(t, p, KB_BASE).child(PRIV_SUFFIX)  
-    
-    try {  
-      const value = await this.ds.get(key)  
-      return keys.privateKeyFromRaw(value)  
-    } catch (err) {  
-      if ((err as { code?: string }).code === 'ERR_NOT_FOUND') return null  
-      throw new Error(`Error getting private key: ${(err as Error).message}`)  
-    }  
-  }  
-
-  async addPrivKey(t: ThreadID, p: PeerId, sk: PrivateKey): Promise<void> {  
-    if (!sk) throw new Error('Private key is null')  
-    
-    const peerId = await peerIdFromPrivateKey(sk)  
-    if (!peerId.equals(p)) {  
-      throw new Error("Peer ID doesn't match private key")  
-    }  
-
-    const value = sk.raw 
-    const key = dsLogKey(t, p, KB_BASE).child(PRIV_SUFFIX)  
-    await this.ds.put(key, value)  
-  }  
-
-
-  async readKey(t: ThreadID): Promise<SymKey|undefined> {  
-    const key = dsThreadKey(t, KB_BASE).child(READ_SUFFIX)  
-    try {  
-      const value = await this.ds.get(key)  
-      let symkey = await symKeyFromBytes(value)
-      return symkey 
-    } catch (err) {  
-      if ((err as { code?: string }).code === 'ERR_NOT_FOUND') return 
-      throw new Error(`Error getting read key: ${(err as Error).message}`)  
-    }  
-  }  
-
-  async addReadKey(t: ThreadID, rk: SymKey): Promise<void> {  
-    if (!rk) throw new Error('Read key is null')  
-    const value = rk.raw
-    const key = dsThreadKey(t, KB_BASE).child(READ_SUFFIX)  
-    await this.ds.put(key, value)  
-  }  
-
-  async serviceKey(t: ThreadID): Promise<SymKey | undefined> {  
-    const key = dsThreadKey(t, KB_BASE).child(SERVICE_SUFFIX)  
-    
-    try {  
-      const value = await this.ds.get(key)  
-      const symkey = await symKeyFromBytes(value)
-      return symkey 
-    } catch (err) {  
-      if ((err as { code?: string }).code === 'ERR_NOT_FOUND') return   
-      throw new Error(`Error getting service key: ${(err as Error).message}`)  
-    }  
-  }  
-
-  async addServiceKey(t: ThreadID, fk: SymKey): Promise<void> {  
-    if (!fk) throw new Error('Service key is null')  
-    const key = dsThreadKey(t, KB_BASE).child(SERVICE_SUFFIX)  
-    await this.ds.put(key, fk.raw)  
-  }  
-
-  async clearKeys(t: ThreadID): Promise<void> {  
-    return this.clearKeysInternal(dsThreadKey(t, KB_BASE))  
-  }  
-
-  async clearLogKeys(t: ThreadID, p: PeerId): Promise<void> {  
-    const baseKey = dsLogKey(t, p, KB_BASE)  
-    await this.ds.delete(baseKey.child(PRIV_SUFFIX))  
-    await this.ds.delete(baseKey.child(PUB_SUFFIX))  
-  }  
-
-  private async clearKeysInternal(prefix: Key): Promise<void> {  
-    const q: Query = {  
-      prefix: prefix.toString(),  
-    }  
-
-    for await (const result of this.ds.query(q)) {  
-      await this.ds.delete(result.key)
-    }  
-  }  
-
-  async logsWithKeys(t: ThreadID): Promise<PeerId[]> {  
-    const threadKey = KB_BASE.child(  
-        new Key(t.toString())  
-    )  
-    
-    return uniqueLogIds(this.ds,threadKey, result =>   
-      result.parent().name()  
-    )  
-  }  
-
-  async threadsFromKeys(): Promise<ThreadID[]> {  
-    return uniqueThreadIds(this.ds,KB_BASE, result =>  
-        result.parent().parent().name()  
-    )  
-  }  
-
-
-  async dumpKeys(): Promise<DumpKeyBook> {  
-    const dump: DumpKeyBook = {  
-      data: {  
-        public: {},  
-        private: {},  
-        read: {},  
-        service: {}  
-      }  
-    }  
-
-    const q: Query = { prefix: KB_BASE.toString() }  
-    const results = this.ds.query(q)  
-
-    for await (const entry of results) {  
-      const key = new Key(entry.key.toString())  
-      const namespaces = key.list()  
-
-      if (namespaces.length < 4) {  
-        throw new Error(`Invalid keybook key: ${entry.key}`)  
-      }  
-
-      const suffix = `/${namespaces[namespaces.length - 1]}`  
-      switch (suffix) {  
-        case PUB_SUFFIX.toString():  
-          this.processPublicKeyEntry(namespaces, entry.value, dump)  
-          break  
-        case PRIV_SUFFIX.toString():  
-          this.processPrivateKeyEntry(namespaces, entry.value, dump)  
-          break  
-        case READ_SUFFIX.toString():  
-          this.processReadKeyEntry(namespaces, entry.value, dump)  
-          break  
-        case SERVICE_SUFFIX.toString():  
-          this.processServiceKeyEntry(namespaces, entry.value, dump)  
-          break  
-        default:  
-          throw new Error(`Invalid key suffix: ${suffix}`)  
-      }  
-    }  
-
-    return dump  
-  }  
-
-  private processPublicKeyEntry(namespaces: string[], value: Uint8Array, dump: DumpKeyBook) {  
-    const [tid, lid] = namespaces.slice(2, 4)    
-  if (!tid || !lid) {  
-      throw new Error(`Invalid namespaces for public key: ${namespaces.join('/')}`)  
-    }
-    const pk = publicKeyFromRaw(value)  
-    if (!dump.data.public[tid]) {  
-      dump.data.public[tid] = {}  
-    }  
-    dump.data.public[tid][lid] = pk  
-  }  
-
-
-  private processPrivateKeyEntry(namespaces: string[], value: Uint8Array, dump: DumpKeyBook) {  
-    const [tid, lid] = namespaces.slice(2, 4)    
-  if (!tid || !lid) {  
-      throw new Error(`Invalid namespaces for private key: ${namespaces.join('/')}`)  
-    }
-    const privk = privateKeyFromRaw(value)  
-    if (!dump.data.private[tid]) {  
-      dump.data.private[tid] = {}  
-    }  
-    dump.data.private[tid][lid] = privk  
-  } 
-
-  private processReadKeyEntry(namespaces: string[], value: Uint8Array, dump: DumpKeyBook) {  
-    const [tid] = namespaces.slice(2, 3)    
-    dump.data.read[tid!] = Buffer.from(value)  
-  } 
-
-  private processServiceKeyEntry(namespaces: string[], value: Uint8Array, dump: DumpKeyBook) {  
-    const [tid] = namespaces.slice(2, 3)   
-  if (!tid) {  
-      throw new Error(`Invalid namespaces for service key: ${namespaces.join('/')}`)  
-    } 
-    dump.data.service[tid] = Buffer.from(value)  
-  } 
-
-async restoreKeys(dump: DumpKeyBook): Promise<void> {
-    if (
-        !AllowEmptyRestore &&
-        Object.keys(dump.data.public).length === 0 &&
-        Object.keys(dump.data.private).length === 0 &&
-        Object.keys(dump.data.read).length === 0 &&
-        Object.keys(dump.data.service).length === 0
-    ) {
-        throw new Error('Empty dump data');
-    }
-
-    // clear all local keys
-    await this.clearKeysInternal(KB_BASE);
-
-    for (const tid in dump.data.public) {
-        for (const lid in dump.data.public[tid]) {
-            const pubKey = dump.data.public[tid][lid];
-            if (!pubKey) {
-                continue
-            }
-            await this.addPubKey(ThreadID.fromString(tid),  peerIdFromPublicKey(pubKey), pubKey);
-        }
-    }
-
-    for (const tid in dump.data.private) {
-        for (const lid in dump.data.private[tid]) {
-            const privKey = dump.data.private[tid][lid];
-            if (!privKey) {
-                continue
-            }
-            await this.addPrivKey(ThreadID.fromString(tid),  peerIdFromPrivateKey(privKey), privKey);
-        }
-    }
-
-    for (const tid in dump.data.read) {
-        const rk = dump.data.read[tid];
-        if (!rk) {
-            continue
-        }
-        const key = await symKeyFromBytes(rk);
-        await this.addReadKey(ThreadID.fromString(tid), key);
-    }
-
-    for (const tid in dump.data.service) {
-        const sk = dump.data.service[tid];
-        if (!sk) {
-            continue
-        }
-        const key = await symKeyFromBytes(sk);
-        await this.addServiceKey(ThreadID.fromString(tid), key);
-    }
-}
-}
-
-export async function newKeyBook(store: Datastore): Promise<DsKeyBook> {  
-  return new DsKeyBook(store)  
-}

package/lib/implements/threaddb/lsstoreds/logstore.ts

@@ -1,29 +0,0 @@
-
-import { Datastore, Key, Query } from 'interface-datastore'  
-import {newAddrBook} from './addr_book'
-import {newKeyBook} from './keybook'
-import {newThreadMetadata} from './metadata'
-import {newHeadBook} from './headbook'
-import * as lstore from '../common/logstore'
-import type { PeerId } from "@libp2p/interface";
-import {  QueryExt, QueryResult, TxnDatastoreExtended,Transaction } from '../core/db'  
-import { peerIdFromString } from "@libp2p/peer-id";
-import { ThreadID } from '@textile/threads-id'; 
-import {  ILogstore} from '../core/logstore' // 假设核心接口定义  
-import {AllowEmptyRestore,EmptyEdgeValue,DSOptions,DefaultOpts} from './global'
-
-
-// 日志存储创建函数  
-export async function newLogstore(  
-  store: Datastore & { transaction?: any },  
-  opts: DSOptions  
-): Promise<ILogstore> {  
-  const addrBook = await newAddrBook( store, opts)  
-  const keyBook = await newKeyBook(store)  
-  const threadMetadata = newThreadMetadata(store)  
-  const headBook = newHeadBook(store as TxnDatastoreExtended)  
-  
-  return lstore.newLogstore(keyBook, addrBook, headBook, threadMetadata)  
-}  
- 
-

package/lib/implements/threaddb/lsstoreds/metadata.ts

@@ -1,223 +0,0 @@
-import { Key, Datastore, Query } from 'interface-datastore'  
-import { IThreadMetadata, DumpMetadata, MetadataKey } from '../core/logstore'
-import { ThreadID } from '@textile/threads-id';
-import * as buffer from "buffer/";
-const { Buffer } = buffer;
-
-const AllowEmptyRestore = false  
-
-// 元数据键前缀  
-const tmetaBase = new Key('/thread/meta')  
-
-
-export function newThreadMetadata(ds: Datastore): DsThreadMetadata {
-    return new DsThreadMetadata(ds);
-}
-
-export class DsThreadMetadata implements IThreadMetadata {  
-  constructor(private readonly ds: Datastore) {}  
-
-  async getInt64(t: ThreadID, key: string): Promise<number | null> {  
-    return this.getValue<number>(t, key)  
-  }  
-
-  async putInt64(t: ThreadID, key: string, val: number): Promise<void> {  
-    return this.setValue(t, key, val)  
-  }  
-
-  async getString(t: ThreadID, key: string): Promise<string | null> {  
-    return this.getValue<string>(t, key)  
-  }  
-
-  async putString(t: ThreadID, key: string, val: string): Promise<void> {  
-    return this.setValue(t, key, val)  
-  }  
-
-  async getBool(t: ThreadID, key: string): Promise<boolean | null> {  
-    return this.getValue<boolean>(t, key)  
-  }  
-
-  async putBool(t: ThreadID, key: string, val: boolean): Promise<void> {  
-    return this.setValue(t, key, val)  
-  }  
-
-  async getBytes(t: ThreadID, key: string): Promise<Uint8Array | null> {  
-    const k = this.keyMeta(t, key)  
-    try {  
-      const value = await this.ds.get(k)  
-      return value
-    } catch (err:any) {
-      if (err.code === 'ERR_NOT_FOUND') return null
-      throw new Error(`Error getting metadata: ${err.message}`)
-    }
-  }  
-
-
-  async putBytes(t: ThreadID, key: string, val: Uint8Array): Promise<void> {  
-    const k = this.keyMeta(t, key)   
-    try {  
-      await this.ds.put(k, val)  
-    } catch (err:any) {  
-      throw new Error(`Error setting metadata: ${err.message}`)  
-    }  
-  }  
-
-  private keyMeta(t: ThreadID, k: string): Key {  
-    const tKey = t.toString()
-    return tmetaBase.child(new Key(tKey)).child(new Key(k))  
-  }  
-
-  private async getValue<T>(t: ThreadID, key: string): Promise<T | null> {  
-    const k = this.keyMeta(t, key)  
-    try {  
-      const value = await this.ds.get(k)  
-      // For Uint8Array we'll handle it in getBytes method
-      return this.decodeValue<T>(value)  
-    } catch (err:any) {
-      if (err.code === 'ERR_NOT_FOUND') return null  
-      throw new Error(`Error getting metadata: ${err.message}`)  
-    }  
-  }  
-
-  private async setValue(t: ThreadID, key: string, val: any): Promise<void> {  
-    const k = this.keyMeta(t, key)  
-    const value = this.encodeValue(val)  
-    try {  
-      await this.ds.put(k, value)  
-    } catch (err:any) {  
-      throw new Error(`Error setting metadata: ${err.message}`)  
-    }  
-  }  
-
-  async clearMetadata(t: ThreadID): Promise<void> {  
-    const prefix = tmetaBase.child(new Key(t.toString())).toString()  
-    return this.clearKeys(prefix)  
-  }  
-
-  async dumpMeta(): Promise<DumpMetadata> {  
-    const dump: DumpMetadata = {  
-      data: {  
-        bool: {},  
-        int64: {},  
-        string: {},  
-        bytes: {}  
-      }  
-    }  
-
-    const results = this.ds.query({ prefix: tmetaBase.toString() })  
-    try {  
-      for await (const entry of results) {  
-        const kns = new Key(entry.key.toString()).list()  
-        if (kns.length < 4) {  
-          throw new Error(`Bad metabook key: ${entry.key}`)  
-        }  
-        const [,, ts, key] = kns  
-        const tid = this.parseThreadID(ts!)  
-        const mk: MetadataKey = { t: tid, k: key! }  
-
-        const value = await this.decodeAnyValue(entry.value)  
-        this.storeDecodedValue(dump, mk, value)  
-      }  
-    } catch (err:any) {  
-      throw new Error(`Error dumping metadata: ${err.message}`)
-    } 
-    return dump  
-  }  
-
-  async restoreMeta(dump: DumpMetadata): Promise<void> {  
-    const dataLen = Object.keys(dump.data.bool).length + Object.keys(dump.data.int64).length +   
-                   Object.keys(dump.data.string).length + Object.keys(dump.data.bytes).length  
-    if (!AllowEmptyRestore && dataLen === 0) {  
-      throw new Error('Empty metadata dump')  
-    }  
-
-    await this.clearKeys(tmetaBase.toString())  
-
-    const entries = [  
-      ...Object.entries(dump.data.bool),  
-      ...Object.entries(dump.data.int64),  
-      ...Object.entries(dump.data.string),  
-      ...Object.entries(dump.data.bytes),  
-    ]  
-
-    for (const [mkStr, value] of entries) {  
-      const mk: MetadataKey = JSON.parse(mkStr);
-      await this.setValue(mk.t, mk.k, value)  
-    }  
-  }  
-
-  private async clearKeys(prefix: string): Promise<void> {  
-    const results = this.ds.queryKeys({ prefix })  
-    try {  
-      for await (const key of results) {  
-        await this.ds.delete(key)
-      }  
-    } catch (err:any) {
-        throw new Error(`Error clearing keys: ${err.message}`)
-    }  
-  }  
-
-  private decodeValue<T>(buf: Uint8Array): T {  
-    try {  
-      const decoder = new TextDecoder()  
-      return JSON.parse(decoder.decode(buf)) as T  
-    } catch (err:any) {  
-      throw new Error(`Value decoding failed: ${err.message}`)  
-    }  
-  }  
-
-  private encodeValue(val: any): Uint8Array {  
-    try {  
-      const encoder = new TextEncoder()  
-      return encoder.encode(JSON.stringify(val))  
-    } catch (err:any) {  
-      throw new Error(`Value encoding failed: ${err.message}`)  
-    }  
-  }  
-
-  private parseThreadID(ts: string): ThreadID {  
-    try {  
-      return ThreadID.fromString(ts)  
-    } catch (err:any) {  
-      throw new Error(`Invalid thread ID: ${ts}`)  
-    }  
-  }  
-
-  private storeDecodedValue(  
-    dump: DumpMetadata,  
-    mk: MetadataKey,  
-    value: any  
-  ) {  
-    switch (typeof value) {  
-      case 'boolean':  
-        dump.data.bool[mk.t.toString()] = dump.data.bool[mk.t.toString()] || {};  
-        dump.data.bool[mk.t.toString()]![mk.k] = value;
-        break  
-      case 'number':  
-        dump.data.int64[mk.t.toString()] = dump.data.int64[mk.t.toString()] || {};
-        dump.data.int64[mk.t.toString()]![mk.k] = value;
-        break  
-      case 'string':  
-        dump.data.string[mk.t.toString()] = dump.data.string[mk.t.toString()] || {};
-        dump.data.string[mk.t.toString()]![mk.k] = value;
-        break  
-      default:  
-        if (value instanceof Uint8Array) {  
-         // dump.data.bytes[mk.t.toString()] = dump.data.bytes[mk.t.toString()] || '';
-          dump.data.bytes[mk.t.toString()] = dump.data.bytes[mk.t.toString()] || {};
-          dump.data.bytes[mk.t.toString()]![mk.k] = value;
-        } else {  
-          throw new Error(`Unsupported value type for key: ${mk.k}`)  
-        }  
-    }  
-  }  
-
-  private async decodeAnyValue(buf: Uint8Array): Promise<any> {  
-    try {  
-      return this.decodeValue<any>(buf)  
-    } catch {  
-      // 原始字节回退  
-      return buf  
-    }  
-  }  
-}

package/lib/implements/threaddb/net/define.ts

@@ -1,149 +0,0 @@
-import { IRecord,IThreadRecord } from '../core/record'; 
-import { ThreadID } from '@textile/threads-id';
-import type { PeerId } from '@libp2p/interface';
-import { registry } from '@multiformats/multiaddr';
-
-
-export const netPullingLimit = 1000; // 拉取记录数的限制
-
-  declare type IProtocol = {
-    code: number;
-    size: number;
-    name: string;
-    resolvable: boolean | undefined;
-    path: boolean | undefined;
-  };
-
-// 协议常量定义  
-export const Protocol = {  
-    code: 406, // 根据实际协议代码调整  
-    name: 'thread', // 协议名称  
-    version: "0.0.1",
-    resolvable: false,
-    path: false,
-    size:-1
-  } 
-  const V = -1
-export const table: Array<[number, number, string, boolean?, boolean?]> = [
-  [4, 32, 'ip4'],
-  [6, 16, 'tcp'],
-  [33, 16, 'dccp'],
-  [41, 128, 'ip6'],
-  [42, V, 'ip6zone'],
-  [43, 8, 'ipcidr'],
-  [53, V, 'dns', true],
-  [54, V, 'dns4', true],
-  [55, V, 'dns6', true],
-  [56, V, 'dnsaddr', true],
-  [132, 16, 'sctp'],
-  [273, 16, 'udp'],
-  [275, 0, 'p2p-webrtc-star'],
-  [276, 0, 'p2p-webrtc-direct'],
-  [277, 0, 'p2p-stardust'],
-  [280, 0, 'webrtc-direct'],
-  [281, 0, 'webrtc'],
-  [290, 0, 'p2p-circuit'],
-  [301, 0, 'udt'],
-  [302, 0, 'utp'],
-  [400, V, 'unix', false, true],
-  // `ipfs` is added before `p2p` for legacy support.
-  // All text representations will default to `p2p`, but `ipfs` will
-  // still be supported
-  [421, V, 'ipfs'],
-  // `p2p` is the preferred name for 421, and is now the default
-  [421, V, 'p2p'],
-  [443, 0, 'https'],
-  [444, 96, 'onion'],
-  [445, 296, 'onion3'],
-  [446, V, 'garlic64'],
-  [448, 0, 'tls'],
-  [449, V, 'sni'],
-  [460, 0, 'quic'],
-  [461, 0, 'quic-v1'],
-  [465, 0, 'webtransport'],
-  [466, V, 'certhash'],
-  [477, 0, 'ws'],
-  [478, 0, 'wss'],
-  [479, 0, 'p2p-websocket-star'],
-  [480, 0, 'http'],
-  [481, V, 'http-path'],
-  [777, V, 'memory']
-]
-function createProtocol (code: number, size: number, name: string, resolvable?: any, path?: any): IProtocol {
-    return {
-      code,
-      size,
-      name,
-      resolvable: Boolean(resolvable),
-      path: Boolean(path)
-    }
-  }
-// populate tables
-table.forEach(row => {
-  const proto = createProtocol(...row)
-  try {
-    // 检查协议是否已存在
-    const existingProto = registry.getProtocol(proto.code)
-    if (!existingProto) {
-      registry.addProtocol(proto)
-    }
-  } catch (error) {
-    // 如果协议不存在，添加新协议
-    registry.addProtocol(proto)
-  }
-})
- // 添加自定义协议
-try {
-  const existingCustomProto = registry.getProtocol(Protocol.code)
-  if (!existingCustomProto) {
-    registry.addProtocol(Protocol)
-  }
-} catch (error) {
-  registry.addProtocol(Protocol)
-}
-
-
-
-/**
- * Records with counters from a peer
- */
-export interface PeerRecords {
-  records: IRecord[];
-  counter: number;
-}
-
-/**
- * Record with timestamp for sorting
- */
-export interface TimestampedRecord {
-  record: IRecord;
-  counter: number;
-  createtime: BigInt;
-  logid: PeerId;
-
-}
-
-
-/**
- * Record implements IThreadRecord
- */
-export class ThreadRecord implements IThreadRecord {
-  constructor(
-    private record: IRecord,
-    private _threadID: ThreadID,
-    private _logID: PeerId
-  ) {}
-
-  value(): IRecord {
-    return this.record;
-  }
-
- threadID(): ThreadID {
-    return this._threadID;
-  }
-
-  logID(): PeerId {
-    return this._logID;
-  }
-}
-