web-dc-api 0.1.5 → 0.1.6

package/lib/implements/threaddb/pb/proto-custom-types.ts

@@ -1,212 +0,0 @@
-// proto-custom-types.ts  
-import { Multiaddr,multiaddr } from '@multiformats/multiaddr'  
-import { CID } from 'multiformats/cid'  
-import  { keys } from '@libp2p/crypto'
-import { PeerId } from "@libp2p/interface";
-import type { PrivateKey, PublicKey, KeyType, RSAPrivateKey, Secp256k1PrivateKey, Ed25519PrivateKey, Secp256k1PublicKey, Ed25519PublicKey } from '@libp2p/interface'
-import {  Key} from '../common/key'
-import { ThreadID } from '@textile/threads-id';
-import { peerIdFromCID, peerIdFromMultihash, peerIdFromString } from '@libp2p/peer-id'
-import { decode } from 'multiformats/hashes/digest';
-
-// Base Types ================================================================  
-type BrandedString<T extends string> = string & { readonly __brand: T }  
-
- 
-export type ProtoKey = BrandedString<'ProtoKey'>
-
-// Peer ID ===================================================================  
-export class PeerIDConverter {  
-  static fromBytes(ibytes: Uint8Array): PeerId {  
-    try {
-      const multihash = decode(ibytes);
-      const peerID = peerIdFromMultihash(multihash);
-      if (peerID == null) {
-        throw new Error('Invalid Peer ID')
-      }
-      return peerID
-    } catch (err: any) {
-      throw new Error('Invalid Peer ID')
-    }
-  }
-
-  static toBytes(id: string): Uint8Array {  
-    const peerID = peerIdFromString(id)
-    if (peerID == null) {
-      throw new Error('Invalid Peer ID')
-    }
-    const peerIDBytes = peerID.toMultihash().bytes
-    return peerIDBytes 
-  }  
-
-
-
-}  
-
-// Multiaddr =================================================================  
-export class MultiaddrConverter {  
-  static fromBytes(bytes: Uint8Array): Multiaddr {  
-    try {  
-      return multiaddr(bytes)  
-    } catch {  
-      throw new Error('Invalid multiaddr bytes')  
-    }  
-  }  
-
-  static toBytes(addr: Multiaddr): Uint8Array {  
-    return addr.bytes  
-  }  
-
- /**
-   * Convert from protobuf address info array to Multiaddr array
-   * 
-   * @param addrs Array of protobuf address info objects
-   * @returns Array of valid multiaddrs
-   */
- static addrsFromProtobuf(addrs: Uint8Array[]): Multiaddr[] {
-  const out: Multiaddr[] = [];
-  
-  for (const addr of addrs) {
-    try {
-      const a = multiaddr(addr);
-      out.push(a);
-    } catch (err) {
-      // Skip invalid addresses
-      continue;
-    }
-  }
-  
-  return out;
-}
-
- /**
-   * Convert from Multiaddr array to protobuf address info array
-   * 
-   * @param addrs Array of multiaddrs
-   * @returns Array of protobuf address info objects
-   */
- static addrsToProtobuf(addrs: Multiaddr[]): Uint8Array[] {
-    const out:  Uint8Array [] = [];
-    
-    for (const addr of addrs) {
-      out.push( addr.bytes );
-    }
-    
-    return out;
-}
-} 
-
-// CID =======================================================================  
-export class CidConverter {  
-  static fromBytes(bytes: Uint8Array): CID {  
-    try {  
-      return CID.decode(bytes)  
-    } catch {  
-      return CID.parse('bafkqaaa') // Undefined CID  
-    }  
-  }  
-
-  static toBytes(c: CID): Uint8Array {  
-    if (c == null) {  
-      return new Uint8Array() // Undefined CID  
-    }
-    return c.bytes  
-  }  
-}  
-
-// Thread ID =================================================================  
-export class ThreadIDConverter {  
-  static fromBytes(bytes: Uint8Array): string {  
-    const id = ThreadID.fromBytes(bytes).toString()
-   
-    return id 
-  }  
-
-  static toBytes(id: string): Uint8Array {  
-    const threadID = ThreadID.fromString(id)
-    return threadID.toBytes()
-  }  
-}  
-
-// Cryptographic Keys ========================================================  
-export class KeyConverter {  
- 
-
-  // Public Key  
-  static async publicFromBytes<T extends PublicKey >(bytes: Uint8Array): Promise<T> {  
-    try {  
-      return  keys.publicKeyFromProtobuf(bytes)  as T
-    } catch {  
-      throw new Error('Invalid public key')  
-    }  
-  }  
-
-  // Private Key  
-  static async privateFromBytes(bytes: Uint8Array): Promise<PrivateKey> {  
-    try {  
-      return  keys.privateKeyFromProtobuf(bytes)
-    } catch {  
-      throw new Error('Invalid private key')  
-    }  
-  }  
-  static async toBytes(key: PrivateKey): Promise<Uint8Array> {
-    try {  
-      return  keys.privateKeyToProtobuf(key)
-    } catch {  
-      throw new Error('Invalid private key')  
-    }  
-  }
-
-  static async publicToBytes(key: PublicKey): Promise<Uint8Array> {
-    try {  
-      return  keys.publicKeyToProtobuf(key)
-    } catch {  
-      throw new Error('Invalid public key')  
-    }  
-  }
-}  
-
-
-// ProtoKey is a custom type used to serialize and deserialize raw keys into the symmetric.Key type, and back.
-
-export class ProtoKeyConverter {
-  static fromBytes(bytes: Uint8Array): string {  
-   const key = Key.fromBytes(bytes)
-    return key.toString() 
-  }  
-
-  static toBytes(pkey: string): Uint8Array {  
-    const key = Key.fromString(pkey)
-    return key.toBytes()
-  } 
-}
-
-
-// JSON Utilities ============================================================  
-export const json = {  
-  parseBytes: (json: string): Uint8Array => {  
-    const arr = JSON.parse(json)  
-    if (!Array.isArray(arr)) throw new Error('Invalid JSON array')  
-    return new Uint8Array(arr)  
-  },  
-  stringifyBytes: (bytes: Uint8Array): string =>   
-    JSON.stringify(Array.from(bytes))  
-}  
-
-// Example Usage =============================================================  
-/*  
-// 在另一个文件中导入使用：  
-import {   
-  PeerIDConverter,  
-  MultiaddrConverter,  
-  CidConverter,  
-  ThreadIDConverter,  
-  KeyConverter,  
-  json  
-} from './proto-custom-types'  
-
-// 转换PeerID  
-const peerBytes = new TextEncoder().encode('QmPNgojgxaxfLh2dfJXPs6f8qHgLueL5t7Yzoe6qkHkJXZ')  
-const peerId = PeerIDConverter.fromBytes(peerBytes)  
-const restoredBytes = PeerIDConverter.toBytes(peerId)  
-*/  

package/lib/implements/util/client.ts

@@ -1,72 +0,0 @@
-import type { Multiaddr } from "@multiformats/multiaddr";
-import type { Client } from "../../common/dcapi";
-import { Libp2pGrpcClient } from "grpc-libp2p-client";
-import { dcnet } from "../../proto/dcnet_proto";
-import { DCContext } from "../../../lib/interfaces/DCContext";
-import { uint32ToLittleEndianBytes } from "../../util/utils";
-import { Errors } from "../../common/error";
-import { Ed25519PrivKey, Ed25519PubKey } from "../../common/dc-key/ed25519";
-import { KeyManager } from "../../common/dc-key/keyManager";
-
-export class UtilClient {
-  client: Client;
-
-  constructor(dcClient: Client) {
-    this.client = dcClient;
-  }
-
-/**
- * 设置应用信息
- * @param context DCContext 上下文对象
- * @param threadId 数据库ID
- * @param rk 读取密钥,主要用来加解密真正的数据
- * @param sk 服务密钥,主要用来处理传输过程加解密
- * @param remark 备注信息
- * @returns Promise resolving when operation completes
- */
-async setAppInfo(appId: Uint8Array,owner: Uint8Array,rewarder: Uint8Array,domain: Uint8Array,blockHeight: number,peerId: string,fid:string,signature: Uint8Array): Promise<void> { 
-  if (this.client.p2pNode == null) {
-      throw new Error("p2pNode is null");
-  }
-  try {
-    // Create gRPC client
-    const grpcClient = new Libp2pGrpcClient(
-      this.client.p2pNode,
-      this.client.peerAddr,
-      this.client.token,
-      this.client.protocol
-    );
-   
-    // Create request message
-    const message = new dcnet.pb.SetAppInfoRequest();
-    message.appId = appId;
-    message.ownerAccount = owner;
-    message.rewardAccount = rewarder;
-    message.domain = domain;
-    message.blockheight = blockHeight;
-    message.peerid = new TextEncoder().encode(peerId);
-    message.fid = new TextEncoder().encode(fid);
-    message.signature = signature;
-    
-    
-    const messageBytes = dcnet.pb.SetAppInfoRequest.encode(message).finish();
-    
-    try {
-      // Make RPC call
-       await grpcClient.unaryCall(
-        "/dcnet.pb.Service/SetAppInfo",
-        messageBytes,
-        30000
-      );
-      return;
-    } catch (error) {
-      throw error;
-    }
-  } catch (error) {
-    console.error("设置APP信息失败:", error);
-    throw error;
-  }
-}
-}
-
-

package/lib/implements/util/manager.ts

@@ -1,146 +0,0 @@
-import type { Multiaddr } from "@multiformats/multiaddr";
-import { ChainUtil } from "../../common/chain";
-import { DcUtil } from "../../common/dcutil";
-import { DCConnectInfo, IAppInfo, NFTBindStatus, User } from "../../common/types/types";
-import { UtilClient } from "./client";
-import { sha256, uint32ToLittleEndianBytes } from "../../util/utils";
-import { Ed25519PrivKey, Ed25519PubKey } from "../../common/dc-key/ed25519";
-import { DCContext } from "../../../lib/interfaces/DCContext";
-import { PeerId } from "@libp2p/interface";
-import {
-  extractPublicKeyFromPeerId,
-  generateSymKeyForPrikey,
-  KeyManager,
-} from "../../common/dc-key/keyManager";
-import { SymmetricKey } from "../threaddb/common/key";
-import { peerIdFromString } from "@libp2p/peer-id";
-import { request } from "http";
-import { Errors } from "../../../lib/common/error";
-import { hexToBytes } from "@noble/curves/abstract/utils";
-
-
-export class UtilManager {
-  dc: DcUtil;
-  chainUtil: ChainUtil | undefined;
-  connectedDc: DCConnectInfo = {};
-  context: DCContext;
-  constructor(context: DCContext) {
-    this.connectedDc = context.connectedDc;
-    this.dc = context.dcutil;
-    this.chainUtil = context.dcChain;
-    this.context = context;
-  }
-
- 
-  /**
-   * 设置应用信息
-   * @param appId 应用ID
-   * @param domain 应用域名
-   * @param owner 应用所有者公钥
-   * @param rewarder 应用奖励者公钥
-   * @returns 用户默认数据库信息
-   */
-  async setAppInfo(
-    appId: string,
-    domain: string,
-    owner: string,
-    rewarder: string,
-    fid: string = "",
-  ): Promise<void> {
-
-    if(!this.context.publicKey || !this.context.ethAddress){
-      throw  Errors.NO_USER_INFO;
-    }
-    if(!this.connectedDc.client){
-      throw Errors.NO_DC_PEER_CONNECTED;
-    }
-    if(!this.connectedDc.nodeAddr){
-      throw Errors.NO_DC_PEER_CONNECTED;
-    }
-    
-    const blockHeight = await this.chainUtil?.getBlockHeight();
-    if (blockHeight === undefined) {
-      throw Errors.FAIL_TO_GET_BLOCKHEIGHT;
-    }
-    let ownerAccount = this.context.publicKey.bytes()
-    if (owner && owner.length > 10) {
-        ownerAccount = Ed25519PubKey.unmarshalString(owner).bytes();
-    }
-    let rewardAccount =  hexToBytes(this.context.ethAddress.slice(2));
-    if (rewarder && rewarder.length > 10) {
-        rewardAccount = hexToBytes(rewarder.slice(2));
-    }
-    if (this.connectedDc.client.token == "") {
-        const token = await this.connectedDc.client.GetToken(
-        this.context.appInfo.appId || "",
-        this.context.publicKey.string(),
-        async (payload: Uint8Array): Promise<Uint8Array> => {
-          return this.context.sign(payload);
-        }
-      );
-      if (!token) {
-        throw Errors.FAIL_TO_GET_TOKEN;
-      }
-    }
-    const utilClient = new UtilClient(this.connectedDc.client);
-    const serverPidStr = this.connectedDc.nodeAddr.getPeerId() || "";
-    const serverPidBytes = new TextEncoder().encode(serverPidStr);
-    const appIdBytes = new TextEncoder().encode(appId);
-    const domainBytes = new TextEncoder().encode(domain);
-    // 生成签名数据
-    const hvalue = uint32ToLittleEndianBytes(blockHeight);
-    const preSign = new Uint8Array(
-        appIdBytes.length +
-        domainBytes.length +
-          ownerAccount.length +
-          rewardAccount.length +
-          hvalue.length +
-          serverPidBytes.length+
-          fid.length
-      );            
-    let offset = 0;
-    preSign.set(appIdBytes, offset);
-    offset += appIdBytes.length;
-    preSign.set(ownerAccount, offset);
-    offset += ownerAccount.length;
-    preSign.set(rewardAccount, offset);
-    offset += rewardAccount.length;
-    preSign.set(domainBytes, offset);
-    offset += domainBytes.length;
-    preSign.set(hvalue, offset);
-    offset += hvalue.length;
-    preSign.set(serverPidBytes, offset);
-    offset += serverPidBytes.length;
-    preSign.set(new TextEncoder().encode(fid), offset);
-    // 使用私钥签名
-    const signature = await this.context.sign(preSign);
-
-    await utilClient.setAppInfo(
-      appIdBytes,
-      ownerAccount,
-      rewardAccount,
-      domainBytes,
-      blockHeight,
-      serverPidStr,
-      fid,
-      signature
-    );
-    return;
-  }
-
-  async getAppInfo( appId: string): Promise<IAppInfo> {
-    if (!this.connectedDc.client) {
-      throw Errors.NO_DC_PEER_CONNECTED;
-    }
-    if (!this.chainUtil) {
-      throw Errors.NO_CHAIN_UTIL;
-    }
-    const appInfo = await this.chainUtil.getAPPInfo(
-      appId 
-    );
-    return appInfo;
-  }
-
-
-
-}