web-dc-api 0.1.5 → 0.1.7

package/lib/implements/threaddb/common/key.ts

@@ -1,290 +0,0 @@
- 
-import { secretbox, randomBytes } from 'tweetnacl'  
-
-import { base32 } from 'multiformats/bases/base32';
-import { SymKey } from '../core/core';
-import { symKeyFromBytes } from '../../../common/dc-key/keyManager';
-import type { PublicKey,PrivateKey } from "@libp2p/interface"; 
-import * as JsCrypto from "jscrypto/es6";
-const { Word32Array, AES, pad, mode, Base64 } = JsCrypto;
-
-// Constants
-const NonceBytes = 12;
-const TagBytes = 16;
-const KeyBytes = 32;
-
-interface EncryptedData {  
-  iv: Uint8Array;       // 初始化向量  
-  ciphertext: ArrayBuffer; // 密文  
-  tag: ArrayBuffer;     // 认证标签  
-}  
-// Error classes
-class CipherTextError extends Error {
-  constructor() {
-    super('malformed cipher text');
-    this.name = 'CipherTextError';
-  }
-}
-
-class InvalidKeyError extends Error {
-  constructor() {
-    super('invalid key');
-    this.name = 'InvalidKeyError';
-  }
-}
-
-/**
- * Key is a wrapper for a symmetric key
- */
-export class SymmetricKey {
-  static readonly keyBytes: number = 32;
-  private _raw: Uint8Array;
-
-  constructor(rawBytes: Uint8Array) {
-    this._raw = rawBytes;
-  }
-
-  /**
-   * Generate a new random key
-   */
-  static newRandom(): SymmetricKey {
-    const rawBytes = randomBytes(KeyBytes);
-    return new SymmetricKey(rawBytes);
-  }
-
-  /**
-   * Creates a key without error handling (will throw if fails)
-   */
-  static new(): SymmetricKey {
-    return SymmetricKey.newRandom();
-  }
-
-  /**
-   * Create a key from raw bytes
-   */
-  static fromBytes(k: Uint8Array): SymmetricKey {
-    if (k.length !== KeyBytes) {
-      throw new InvalidKeyError();
-    }
-    return new SymmetricKey(k);
-  }
-
-  /**
-   * Create a key from a base32-encoded string
-   */
-  static fromString(k: string): SymmetricKey {
-    try {
-      const bytes = base32.decode(k);
-      return SymmetricKey.fromBytes(bytes);
-    } catch (err) {
-      throw new Error(`Failed to decode key: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-    async toSymKey(): Promise<SymKey> {
-      const symKey =   symKeyFromBytes(this._raw);
-      return symKey
-    }
-  
-    static fromSymKey(symKey: SymKey): SymmetricKey {
-      return new SymmetricKey(symKey.raw)
-    }
-
-  /**
-   * Get raw key bytes
-   */
-  get raw(): Uint8Array {
-    return this._raw;
-  }
-
-  /**
-   * Return raw key bytes
-   */
-  bytes(): Uint8Array {
-    return this._raw;
-  }
-
-  /**
-   * Convert key to binary format
-   */
-  marshalBinary(): Uint8Array {
-    return this._raw;
-  }
-
-  /**
-   * Return base32-encoded string representation
-   */
-  toString(): string {
-    try {
-      return base32.encode(this.raw);
-    } catch (err) {
-      throw new Error(`Failed to encode key: ${err instanceof Error ? err.message : String(err)}`);
-    }
-  }
-
-  // /**
-  //  * Encrypt performs AES-256 GCM encryption on plaintext
-  //  */
-  // encrypt(plaintext: Uint8Array): Uint8Array {
-  //   // Generate a random nonce
-  //   const nonce = randomBytes(secretbox.nonceLength)  ;
-    
-  //   const box = secretbox(plaintext, nonce, this._raw)  
-  //   const encrypted = new Uint8Array(nonce.length + box.length)  
-  //   encrypted.set(nonce)  
-  //   encrypted.set(box, nonce.length)  
-  //   return encrypted  
-  // }
- 
-  
-async  encrypt(  
-  plaintext: Uint8Array,   
-  exNonce?: Uint8Array
-): Promise<Uint8Array> {  
-  let nonce = randomBytes(NonceBytes);
-  if(exNonce && exNonce.length === NonceBytes) {
-    nonce = exNonce;
-  }
-  // 生成随机初始化向量 (96 bits)  
-  const iv = crypto.getRandomValues(nonce);  
-  // 加密配置  
-  const algorithm = {  
-    name: "AES-GCM",  
-    iv: iv,  
-    tagLength: 128 // 认证标签长度 (bits)  
-  };  
-  const symKey = await this.toSymKey();
-  // 执行加密  
-  const ciphertext = await crypto.subtle.encrypt(  
-    algorithm,  
-    symKey.key,  
-    plaintext as any
-  );  
-  // 提取认证标签（最后16字节）  
-  //const tag = ciphertext.slice(ciphertext.byteLength - 16);  
-  
-  // 分离密文主体（去除标签）  
- // const ciphertextBody = ciphertext.slice(0, ciphertext.byteLength - 16);  
-  const result = new Uint8Array(nonce.length + ciphertext.byteLength);
-  result.set(nonce, 0);
-  result.set(new Uint8Array(ciphertext), nonce.length);
-  return result;
-} 
-
-
-
-
-
-  /**
-   * Decrypt uses key to perform AES-256 GCM decryption on ciphertext
-   */
-  async decrypt(encryptBuffer: Uint8Array): Promise<Uint8Array> {
-  
-   if (encryptBuffer.length <= 28) {
-      return encryptBuffer;
-    }
-    const nonce = encryptBuffer.subarray(0, NonceBytes);
-    const iv = new Word32Array(nonce);
-    const tag = encryptBuffer.subarray(
-      encryptBuffer.length - TagBytes,
-      encryptBuffer.length
-    );
-    const kdfSalt = new Word32Array(tag);
-    const encryptContent = encryptBuffer.subarray(
-      NonceBytes,
-      encryptBuffer.length - TagBytes
-    );
-    const cipherText = new Word32Array(encryptContent);
-    const key = new Word32Array(this._raw);
-    const decrypted = AES.decrypt(cipherText.toString(Base64), key, {
-      iv: iv,
-      padding: pad.NoPadding,
-      mode: mode.GCM,
-      kdfSalt: kdfSalt,
-    });
-    return decrypted.toUint8Array();
-}
-}
-
-
-
-
-
-export type LogKey = PrivateKey | PublicKey 
-
-export class Key {  
-  private sk?: SymmetricKey 
-  private rk?: SymmetricKey
-
-  constructor(sk: SymmetricKey , rk?: SymmetricKey ) {  
-    this.sk = sk  
-    if(rk) {  
-      this.rk = rk  
-    }
-  }  
-
-  static new(sk: SymmetricKey, rk?: SymmetricKey ): Key {  
-    if (!sk) {  
-      throw new Error('service-key must not be null')  
-    }  
-    return new Key(sk, rk)  
-  }  
-
-  static newRandom(): Key {  
-    return new Key(SymmetricKey.new(), SymmetricKey.new())  
-  }  
-
-  static newRandomService(): Key {  
-    return new Key(SymmetricKey.new())  
-  }  
-
-  static fromBytes(b: Uint8Array): Key {  
-    if (b.length !== SymmetricKey.keyBytes && b.length !== SymmetricKey.keyBytes * 2) {  
-      throw new Error('invalid key')  
-    }  
-
-    const sk = SymmetricKey.fromBytes(b.slice(0, SymmetricKey.keyBytes))   
-    if (b.length === SymmetricKey.keyBytes * 2) {  
-      const rk = SymmetricKey.fromBytes(b.slice(SymmetricKey.keyBytes))  
-      return new Key(sk,rk)
-    }  
-    return new Key(sk)  
-  }  
-
-  static fromString(s: string): Key {  
-    const decoded = base32.decode(s)  
-    return Key.fromBytes(decoded)  
-  }  
-
-  service(): SymmetricKey|undefined {  
-    return this.sk  
-  }  
-
-  read(): SymmetricKey|undefined  {  
-    return this.rk  
-  }  
-
-  defined(): boolean {  
-    return this.sk !== null  
-  }  
-
-  canRead(): boolean {  
-    return this.rk !== null  
-  }  
-
-  toBytes(): Uint8Array {  
-    if (this.rk  && this.sk) {  
-      return new Uint8Array([...this.sk.bytes(), ...this.rk.bytes()])  
-    } else if (this.sk ) {  
-      return this.sk.bytes()  
-    } else {  
-      return new Uint8Array(0)  
-    }  
-  }  
-
-  toString(): string {  
-    return base32.encode(this.toBytes())  
-  }  
-
-
-}

package/lib/implements/threaddb/common/level-adapter.ts

@@ -1,235 +0,0 @@
-import { Key, Query, Batch, Pair, KeyQuery } from 'interface-datastore'  
-import { LevelDatastore } from 'datastore-level'  
-import {  QueryExt, QueryResult, Transaction,TxnDatastoreExtended } from '../core/db'  
-import { AbortOptions } from '@libp2p/interface';
-type AwaitIterable<T> = AsyncIterable<T> | Iterable<T>;  
-
-
-class LevelDatastoreAdapter implements TxnDatastoreExtended {  
-    private store: LevelDatastore;  
-    private txn: any; 
-  
-    constructor(store: LevelDatastore) {  
-      this.store = store;  
-      this.txn = null; 
-    }  
-  
-    // 修改 queryKeys 的实现  
-    async *queryKeys(  
-      query: KeyQuery,  
-      options?: AbortOptions  
-    ): AsyncIterable<Key> {  
-      const { filters = [], prefix } = query;  
-      const queryOptions: Query = {};
-        if (prefix !== undefined) {
-          queryOptions.prefix = prefix;
-        }
-      for await (const { key } of this.store.query(queryOptions)) {  
-        let match = true;  
-        
-        // 应用所有过滤器  
-        for (const filter of filters) {  
-          if (!filter(key)) {  
-            match = false;  
-            break;  
-          }  
-        }  
-  
-        if (match) {  
-          yield key;  
-        }  
-      }  
-    }  
-  
-    // 修改 query 方法  
-    async *query(  
-      query: Query,  
-      options?: AbortOptions  
-    ): AsyncIterable<{ key: Key; value: Uint8Array }> {  
-      yield* this.store.query(query);  
-    }  
-  
-    // 扩展查询方法  
-    
-  // 修改 queryExtended 的实现  
-  async *queryExtended(  
-    q: QueryExt  
-  ): AsyncIterable<QueryResult> {  
-    const { prefix, filters = [] } = q;  
- const queryOptions: Query = {};
-        if (prefix !== undefined) {
-          queryOptions.prefix = prefix;
-        }
-    for await (const entry of this.store.query(queryOptions)) {  
-      let match = true;  
-      
-      // 应用所有过滤器  
-      for (const filter of filters) {  
-        if (!filter(entry)) {  
-          match = false;  
-          break;  
-        }  
-      }  
-
-      if (match) {  
-        yield {  
-          key: entry.key.toString(),  
-          value: entry.value,  
-          size: entry.value.length  
-        };  
-      }  
-    }  
-  }  
-  
-    // 其他批量操作方法  
-    async *putMany(  
-      source: AwaitIterable<Pair>,  
-      options?: AbortOptions  
-    ): AsyncIterable<Key> {  
-      const batch = this.batch();  
-      
-      for await (const entry of source) {  
-        const key = entry.key;  
-        batch.put(key, entry.value);  
-        yield key;  
-      }  
-      
-      await batch.commit();  
-    }  
-  
-    async *getMany(  
-      source: AwaitIterable<Key>,  
-      options?: AbortOptions  
-    ): AsyncIterable<Pair> {  
-      for await (const key of source) {  
-        try {  
-          const value = await this.get(key);  
-          yield {  
-            key: key,  
-            value  
-          };  
-        } catch (err) {  
-          console.error(`Error getting key ${key}:`, err);  
-        }  
-      }  
-    }  
-  
-    async *deleteMany(  
-      source: AwaitIterable<Key>,  
-      options?: AbortOptions  
-    ): AsyncIterable<Key> {  
-      const batch = this.batch();  
-      
-      for await (const key of source) {  
-        batch.delete(key);  
-        yield key;  
-      }  
-      
-      await batch.commit();  
-    }  
-  
-    // 基本操作方法  
-    async put(key: Key, value: Uint8Array): Promise<Key> {  
-      return this.store.put(key, value);  
-    }  
-  
-    async get(key: Key): Promise<Uint8Array> {  
-      return this.store.get(key);  
-    }  
-  
-    async has(key: Key): Promise<boolean> {  
-      return this.store.has(key);  
-    }  
-  
-    async delete(key: Key): Promise<void> {  
-      return this.store.delete(key);  
-    }  
-  
-    batch(): Batch {  
-      return this.store.batch();  
-    }  
-  
-
-  // 实现 TxnDatastoreExtended 接口的方法  
-  async newTransactionExtended(  
-    
-    readOnly: boolean  
-  ): Promise<Transaction> {  
-    const store = this.store;
-    // 由于 LevelDatastore 不支持原生事务，我们创建一个简单的包装器  
-    const txn: Transaction = {  
-      put: async ( key: Key, value: Uint8Array): Promise<Key> => {  
-        if (readOnly) throw new Error('Transaction is read-only');  
-        await this.store.put(key, value);  
-        return key;  
-      },  
-
-      get: async ( key: Key): Promise<Uint8Array> => {  
-        return this.store.get(key);  
-      },  
-
-      has: async ( key: Key): Promise<boolean> => {  
-        return this.store.has(key);  
-      },  
-
-      delete: async ( key: Key): Promise<void> => {  
-        if (readOnly) throw new Error('Transaction is read-only');  
-        await this.store.delete(key);  
-        return  ;
-      },  
-
-      query: async function*( q: Query): AsyncIterable<QueryResult> {  
-        for await (const entry of store.query(q)) {  
-          yield {  
-            key: entry.key.toString(),  
-            value: entry.value,  
-            size: entry.value.length  
-          };  
-        }  
-      }.bind(this),  
-
-      queryExtended: async function*( q: QueryExt): AsyncIterable<QueryResult> {  
-        const { prefix, filters = [] } = q;  
-        const queryOptions: Query = {};
-        if (prefix !== undefined) {
-          queryOptions.prefix = prefix;
-        }
-        for await (const entry of store.query(queryOptions)) {  
-          let match = true;  
-          for (const filter of filters) {  
-            if (!filter(entry)) {  
-              match = false;  
-              break;  
-            }  
-          }  
-          if (match) {  
-            yield {  
-              key: entry.key.toString(),   
-              value: entry.value,  
-              size: entry.value.length  
-            };  
-          }  
-        }  
-      }.bind(this),  
-
-      commit: async (): Promise<void> => {  
-        // 由于没有实际的事务支持，这里是一个空操作  
-        return Promise.resolve();  
-      } , 
-      discard: async (): Promise<void> => {  
-        // 由于没有实际的事务支持，这里是一个空操作  
-        return Promise.resolve();  
-      } 
-    };  
-
-    return txn; 
-  }  
-}  
-
-// 工厂函数  
-export function createTxnDatastore(path: string): TxnDatastoreExtended {  
-  const levelStore = new LevelDatastore(path);  
-  const adapter = new LevelDatastoreAdapter(levelStore);  
-  return adapter;
-
-}  

package/lib/implements/threaddb/common/lineReader.ts

@@ -1,79 +0,0 @@
-/**
- * 从ReadableStream逐行读取数据的工具类
- */
-export class LineReader {
-    private reader: ReadableStreamDefaultReader<Uint8Array>;
-    private textDecoder: TextDecoder;
-    private buffer: string = '';
-    private isEOF: boolean = false;
-  
-    /**
-     * 创建LineReader实例
-     * @param stream 可读数据流
-     * @param encoding 文本编码（默认为'utf-8'）
-     */
-    constructor(
-      stream: ReadableStream<Uint8Array>,
-      encoding: string = 'utf-8'
-    ) {
-      this.reader = stream.getReader();
-      this.textDecoder = new TextDecoder(encoding);
-    }
-  
-    /**
-     * 读取下一行数据
-     * @returns 返回一行数据，如果到达流末尾则返回null
-     */
-    async readLine(): Promise<string | null> {
-      // 如果已经到达EOF且缓冲区为空，则返回null
-      if (this.isEOF && this.buffer.length === 0) {
-        return null;
-      }
-  
-      // 尝试从缓冲区中找到一行
-      const newlineIndex = this.buffer.indexOf('\n');
-      
-      if (newlineIndex !== -1) {
-        // 找到完整行，提取并更新缓冲区
-        const line = this.buffer.substring(0, newlineIndex);
-        this.buffer = this.buffer.substring(newlineIndex + 1);
-        return line;
-      }
-      
-      // 需要读取更多数据
-      if (!this.isEOF) {
-        const { value, done } = await this.reader.read();
-        
-        if (done) {
-          // 流结束，返回剩余的缓冲区内容作为最后一行
-          this.isEOF = true;
-          if (this.buffer.length > 0) {
-            const lastLine = this.buffer;
-            this.buffer = '';
-            return lastLine;
-          }
-          return null;
-        }
-        
-        // 将新数据添加到缓冲区并递归调用
-        this.buffer += this.textDecoder.decode(value, { stream: true });
-        return this.readLine();
-      }
-      
-      // 已到达EOF，但缓冲区还有内容
-      if (this.buffer.length > 0) {
-        const lastLine = this.buffer;
-        this.buffer = '';
-        return lastLine;
-      }
-      
-      return null;
-    }
-  
-    /**
-     * 释放读取器资源
-     */
-    release(): void {
-      this.reader.releaseLock();
-    }
-  }