web-dc-api 0.0.58 → 0.0.59

package/dist/cjs/implements/threaddb/cbor/node.js

@@ -0,0 +1,398 @@
+'use strict';
+
+var cid = require('../../../node_modules/multiformats/dist/src/cid.js');
+var dagCBOR = require('@ipld/dag-cbor');
+var sha2Browser = require('../../../node_modules/multiformats/dist/src/hashes/sha2-browser.js');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var dagCBOR__namespace = /*#__PURE__*/_interopNamespaceDefault(dagCBOR);
+
+// 错误定义
+const Errors = {
+  ErrNoSuchLink: new Error('no such link found'),
+  ErrNonLink: new Error('non-link found at given path'),
+  ErrInvalidLink: new Error('link value should have been bytes'),
+  ErrInvalidKeys: new Error('map keys must be strings'),
+  ErrArrayOutOfRange: new Error('array index out of range'),
+  ErrNoLinks: new Error('tried to resolve through object that had no links'),
+  ErrEmptyLink: new Error('link value was empty'),
+  ErrInvalidMultibase: new Error('invalid multibase on IPLD link'),
+  ErrNonStringLink: new Error('link should have been a string')
+};
+class Block {
+  constructor(data, cid) {
+    Object.defineProperty(this, "_data", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_cid", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._data = data;
+    this._cid = cid;
+  }
+  data() {
+    return this._data;
+  }
+  cid() {
+    return this._cid;
+  }
+}
+// Node 类
+class Node {
+  constructor(obj, tree, links, raw, cid) {
+    Object.defineProperty(this, "_obj", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_tree", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_links", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_raw", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_cid", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._obj = obj;
+    this._tree = tree;
+    this._links = links;
+    this._raw = raw;
+    this._cid = cid;
+  }
+  // 解析路径并返回找到的对象
+  resolve(path) {
+    let cur = this._obj;
+    for (let i = 0; i < path.length; i++) {
+      const val = path[i];
+      if (typeof cur === 'object' && cur !== null) {
+        if (Array.isArray(cur)) {
+          const n = parseInt(val);
+          if (isNaN(n)) {
+            return [null, null, new Error('array index was not a number')];
+          }
+          if (n < 0 || n >= cur.length) {
+            return [null, null, Errors.ErrArrayOutOfRange];
+          }
+          cur = cur[n];
+        } else if (isCID(cur)) {
+          return [{
+            cid: cur
+          }, path.slice(i), null];
+        } else {
+          const next = cur[val];
+          if (next === undefined) {
+            return [null, null, Errors.ErrNoSuchLink];
+          }
+          cur = next;
+        }
+      } else {
+        return [null, null, Errors.ErrNoLinks];
+      }
+    }
+    if (isCID(cur)) {
+      return [{
+        cid: cur
+      }, null, null];
+    }
+    try {
+      const jsonish = this.convertToJSONIsh(cur);
+      return [jsonish, null, null];
+    } catch (err) {
+      return [null, null, err];
+    }
+  }
+  // 解析路径并返回链接
+  resolveLink(path) {
+    try {
+      const [obj, rest, err] = this.resolve(path);
+      if (err) {
+        return [null, null, err];
+      }
+      if (!obj || !obj.cid || !isCID(obj.cid)) {
+        return [null, rest, Errors.ErrNonLink];
+      }
+      return [obj, rest, null];
+    } catch (err) {
+      return [null, null, err];
+    }
+  }
+  // 返回指定路径和深度的树
+  tree(path, depth) {
+    if (path === '' && depth === -1) {
+      return [...this._tree]; // Return a copy
+    }
+    const out = [];
+    for (const t of this._tree) {
+      if (!t.startsWith(path)) {
+        continue;
+      }
+      const sub = t.substring(path.length).replace(/^\/+/, '');
+      if (sub === '') {
+        continue;
+      }
+      if (depth < 0) {
+        out.push(sub);
+        continue;
+      }
+      const parts = sub.split('/');
+      if (parts.length <= depth) {
+        out.push(sub);
+      }
+    }
+    return out;
+  }
+  // 返回节点的所有链接
+  links() {
+    return [...this._links]; // Return a copy
+  }
+  // 返回节点的原始数据
+  rawData() {
+    return new Uint8Array(this._raw); // Return a copy
+  }
+  // 返回节点的原始数据,兼容IBlock
+  data() {
+    return new Uint8Array(this._raw); // Return a copy
+  }
+  // 返回节点的 CID
+  cid() {
+    return this._cid;
+  }
+  // 返回可记录的节点表示
+  loggable() {
+    return {
+      node_type: 'cbor',
+      cid: this.cid.toString()
+    };
+  }
+  // 返回节点的大小
+  size() {
+    return this._raw.length;
+  }
+  // 返回节点的统计信息
+  stat() {
+    return {};
+  }
+  // 返回节点的 CID 字符串表示
+  toString() {
+    return this.cid.toString();
+  }
+  // 转换为 JSON
+  toJSON() {
+    return this.convertToJSONIsh(this._obj);
+  }
+  // 创建节点的副本
+  copy() {
+    const links = [...this._links];
+    const raw = new Uint8Array(this._raw);
+    const tree = [...this._tree];
+    return new Node(this.copyObj(this._obj), tree, links, raw, this._cid);
+  }
+  // 深拷贝对象
+  copyObj(i) {
+    if (i === null || i === undefined) {
+      return i;
+    }
+    if (Array.isArray(i)) {
+      return i.map(v => this.copyObj(v));
+    }
+    if (typeof i === 'object') {
+      if (isCID(i)) {
+        return i;
+      }
+      const out = {};
+      for (const [k, v] of Object.entries(i)) {
+        out[k] = this.copyObj(v);
+      }
+      return out;
+    }
+    return i; // 原始值直接返回
+  }
+  // 转换为 JSON 兼容格式
+  convertToJSONIsh(v) {
+    if (v === null || v === undefined) {
+      return v;
+    }
+    if (Array.isArray(v)) {
+      if (v.length === 0) {
+        return [];
+      }
+      return v.map(i => this.convertToJSONIsh(i));
+    }
+    if (typeof v === 'object') {
+      if (isCID(v)) {
+        return {
+          '/': v.toString()
+        };
+      }
+      const out = {};
+      for (const [k, val] of Object.entries(v)) {
+        out[k] = this.convertToJSONIsh(val);
+      }
+      return out;
+    }
+    return v; // 原始值直接返回
+  }
+}
+// 从原始数据解码节点
+async function decode(data) {
+  const obj = dagCBOR__namespace.decode(data);
+  return await wrapObject(obj);
+  // try {
+  //     let canonicalData: Uint8Array = data;
+  //     let obj: any;
+  //     try {
+  //        obj = dagCBOR.decode(data);
+  //        // 重新编码确保规范化
+  //        canonicalData = dagCBOR.encode(obj);
+  //     } catch (err) {
+  //     }
+  //       // 创建 CID
+  //       const hash = await sha256.digest(canonicalData);
+  //       const cid = CID.createV1(dagCBOR.code, hash);
+  //       const oldCid = new CID_IPLD(cid.toString());
+  //       // 创建自定义Block对象
+  //       const block = new Block(
+  //         canonicalData,
+  //         cid
+  //       )
+  //       return await newObject(block, obj);
+  //     } catch (err) {
+  //       throw new Error(`Failed to decode data: ${err instanceof Error ? err.message : String(err)}`);
+  //     }
+}
+async function wrapObject(obj) {
+  try {
+    // 编码对象
+    const data = dagCBOR__namespace.encode(obj);
+    // 创建 CID
+    const hash = await sha2Browser.sha256.digest(data);
+    const cid$1 = cid.CID.createV1(dagCBOR__namespace.code, hash);
+    // 创建块
+    const block = new Block(data, cid$1);
+    // 创建兼容 Uint8Array 的深拷贝
+    const clone = structuredClone(obj) || deepCopyWithTypedArrays(obj);
+    return await newObject(block, clone);
+  } catch (err) {
+    throw new Error(`Failed to wrap object: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+// 兼容性深拷贝函数
+function deepCopyWithTypedArrays(obj) {
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+  // 区分处理 ArrayBuffer 和 ArrayBufferView
+  if (obj instanceof ArrayBuffer) {
+    // ArrayBuffer 直接创建新副本
+    return new Uint8Array(obj).buffer;
+  }
+  // 处理 TypedArrays (ArrayBufferView)
+  if (ArrayBuffer.isView(obj)) {
+    // 从视图创建新副本
+    return new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength);
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(item => deepCopyWithTypedArrays(item));
+  }
+  if (typeof obj === 'object' && !isCID(obj)) {
+    const copy = {};
+    for (const [key, value] of Object.entries(obj)) {
+      copy[key] = deepCopyWithTypedArrays(value);
+    }
+    return copy;
+  }
+  // 原始值、CID 直接返回
+  return obj;
+}
+// 创建新的节点对象
+async function newObject(block, obj) {
+  try {
+    const [tree, links] = await compute(obj);
+    return new Node(obj, tree, links, block.data(), block.cid());
+  } catch (err) {
+    throw new Error(`Failed to create node: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+// 计算对象的树和链接
+async function compute(obj) {
+  const tree = [];
+  const links = [];
+  await traverse(obj, '', (name, val) => {
+    if (name !== '') {
+      tree.push(name.substring(1)); // 去除开头的 /
+    }
+    if (val && isCID(val)) {
+      links.push(val);
+    }
+    return null;
+  });
+  return [tree, links];
+}
+// 遍历对象
+async function traverse(obj, cur, cb) {
+  const err = cb(cur, obj);
+  if (err) throw err;
+  if (obj === null || obj === undefined) {
+    return;
+  }
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      const path = `${cur}/${i}`;
+      await traverse(obj[i], path, cb);
+    }
+    return;
+  }
+  if (typeof obj === 'object' && !isCID(obj)) {
+    for (const [k, v] of Object.entries(obj)) {
+      const path = `${cur}/${k}`;
+      await traverse(v, path, cb);
+    }
+  }
+}
+function isCID(value) {
+  return cid.CID.asCID(value) !== null;
+}
+
+exports.Block = Block;
+exports.Node = Node;
+exports.decode = decode;
+exports.wrapObject = wrapObject;

package/dist/cjs/implements/threaddb/cbor/record.js

@@ -0,0 +1,290 @@
+'use strict';
+
+var cid = require('../../../node_modules/multiformats/dist/src/cid.js');
+var dagCBOR = require('@ipld/dag-cbor');
+var node = require('./node.js');
+var event = require('./event.js');
+var coding = require('./coding.js');
+var net_pb = require('../pb/net_pb.js');
+var protoCustomTypes = require('../pb/proto-custom-types.js');
+var multiaddr = require('@multiformats/multiaddr');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var dagCBOR__namespace = /*#__PURE__*/_interopNamespaceDefault(dagCBOR);
+
+/**
+ * 从给定的块和日志私钥创建新记录
+ * @param ctx 上下文
+ * @param dag DAG服务
+ * @param config 记录创建配置
+ * @returns 创建的记录
+ */
+async function CreateRecord(bstore, config) {
+  // 序列化公钥
+  const pkb = await protoCustomTypes.KeyConverter.publicToBytes(config.pubKey);
+  // 创建签名有效载荷
+  let payload;
+  if (config.prev && cid.CID.asCID(config.prev) !== null) {
+    // 连接块CID和前一个CID的字节
+    const blockBytes = config.block.cid().bytes;
+    const prevBytes = config.prev.bytes;
+    payload = new Uint8Array(blockBytes.length + prevBytes.length);
+    payload.set(blockBytes);
+    payload.set(prevBytes, blockBytes.length);
+  } else {
+    payload = pkb;
+  }
+  // 使用私钥签名
+  const sig = await config.key.sign(payload);
+  // 创建记录对象
+  const obj = {
+    block: config.block.cid(),
+    sig: sig,
+    pubKey: pkb
+  };
+  if (config.prev) {
+    obj.prev = config.prev;
+  }
+  const node$1 = await node.wrapObject(obj);
+  // 将对象打包为CBOR节点
+  // const bytes = dagCBOR.encode(obj);
+  // const hash = await sha256.digest(bytes);
+  // const cid = CID.createV1(dagCBOR.code, hash);
+  // const node = new Block(bytes,cid );
+  // 使用服务密钥加密节点
+  const coded = await coding.encodeBlock(node$1, config.serviceKey);
+  if (bstore) {
+    await bstore.put(coded.cid(), coded.data());
+  }
+  // 返回Record实例
+  return new Record(coded, obj, config.block);
+}
+/**
+ * 从给定CID获取记录
+ * @param ctx 上下文
+ * @param dag DAG服务
+ * @param id 记录CID
+ * @param key 解密密钥
+ * @returns 获取的记录
+ */
+async function GetRecord(dag, id, key) {
+  const blockData = await dag.get(id);
+  const decrypt = await key.decrypt(blockData);
+  const decoded = dagCBOR__namespace.decode(decrypt);
+  decoded.block = id; //使用加密后且cborencode后数据的cid
+  // const dblock = await dag.get<Uint8Array>(decoded.block);
+  const wrapedRnode = await node.wrapObject(blockData);
+  const record = new Record(wrapedRnode, decoded);
+  return record;
+}
+/**
+ * 将日志信息转换为protobuf格式
+ * @param info 日志信息
+ * @returns protobuf格式的日志
+ */
+async function logToProto(lg) {
+  if (!lg.pubKey) {
+    throw new Error('Missing required fields in LogInfo: pubKey');
+  }
+  const publicKeyBytes = await protoCustomTypes.KeyConverter.publicToBytes(lg.pubKey);
+  const lgid = lg.id.toString();
+  const idBytes = protoCustomTypes.PeerIDConverter.toBytes(lgid);
+  const addrs = lg.addrs ? lg.addrs.map(addr => addr.bytes) : [];
+  // 创建protobuf日志对象
+  const log = {
+    ID: idBytes,
+    pubKey: publicKeyBytes,
+    addrs: addrs,
+    head: lg.head?.id ? lg.head.id.bytes : undefined,
+    counter: lg.head?.counter
+  };
+  return log;
+}
+/**
+ * 将protobuf格式的日志转换为应用格式
+ * @param protoLog protobuf格式的日志
+ * @returns 应用格式的日志信息
+ */
+async function logFromProto(protoLog) {
+  if (!protoLog.ID || !protoLog.pubKey) {
+    throw new Error('Missing required fields in Log: ID or pubKey');
+  }
+  // const multihash = decode(protoLog.ID);
+  // const id = peerIdFromMultihash(multihash);
+  // 解析日志ID
+  const id = protoCustomTypes.PeerIDConverter.fromBytes(protoLog.ID);
+  // 解析公钥
+  const pubKey = await protoCustomTypes.KeyConverter.publicFromBytes(protoLog.pubKey);
+  // 解析地址
+  const addrs = (protoLog.addrs || []).map(addr => multiaddr.multiaddr(addr));
+  // 解析头部信息
+  const head = protoLog.head && protoLog.head.length > 0 ? cid.CID.decode(protoLog.head) : undefined;
+  // 解析计数器
+  const counter = protoLog.counter ? Number(protoLog.counter) : 0;
+  return {
+    id,
+    pubKey,
+    addrs,
+    managed: true,
+    head: {
+      id: head,
+      counter
+    }
+  };
+}
+/**
+ * 将记录转换为用于传输的proto版本
+ * 节点以加密形式发送
+ * @param ctx 上下文
+ * @param dag DAG服务
+ * @param rec 记录
+ * @returns proto记录
+ */
+async function RecordToProto(bstore, rec) {
+  const block = await rec.getBlock(bstore);
+  let event$1;
+  if (block instanceof event.Event) {
+    event$1 = block;
+  } else {
+    event$1 = await event.EventFromNode(block);
+  }
+  const header = await event$1.getHeader(bstore);
+  const body = await event$1.getBody(bstore);
+  const record = new net_pb.net.pb.Log.Record();
+  record.recordNode = rec.data();
+  record.eventNode = event$1.data();
+  record.headerNode = header.data();
+  record.bodyNode = body.data();
+  return record;
+}
+async function RecordFromProto(rec, key) {
+  if (!key) {
+    throw new Error("解密密钥是必需的");
+  }
+  const encryptRec = dagCBOR__namespace.decode(rec.recordNode);
+  const recData = await key.decrypt(encryptRec);
+  const recObj = dagCBOR__namespace.decode(recData);
+  const rnode = await node.decode(rec.recordNode);
+  recObj.block = rnode.cid(); //使用加密后且cborencode后数据的cid
+  // 解析记录对象
+  const eventNode = await node.decode(rec.eventNode);
+  const headerNode = await node.decode(rec.headerNode);
+  const bodyNode = await node.decode(rec.bodyNode);
+  // 解析事件对象
+  const eobj = dagCBOR__namespace.decode(eventNode.rawData());
+  // 创建事件头和事件
+  const eventHeader = new event.EventHeader(headerNode);
+  const event$1 = new event.Event(eventNode, eobj, eventHeader, bodyNode);
+  // 返回记录
+  return new Record(rnode, recObj, event$1);
+}
+/**
+ * 表示记录的IPLD节点
+ */
+class Record {
+  constructor(node, obj, block) {
+    Object.defineProperty(this, "_node", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_obj", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_block", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this._node = node;
+    this._obj = obj;
+    if (block) {
+      this._block = block;
+    }
+  }
+  cid() {
+    return this._node.cid();
+  }
+  rawData() {
+    return this._node.rawData();
+  }
+  blockID() {
+    return this._obj.block;
+  }
+  async getBlock(bstore) {
+    if (this._block) {
+      return this._block;
+    }
+    const data = await bstore.get(this._obj.block);
+    this._block = await node.wrapObject(data);
+    return this._block;
+  }
+  prevID() {
+    return this._obj.prev;
+  }
+  sig() {
+    return this._obj.sig;
+  }
+  pubKey() {
+    return this._obj.pubKey;
+  }
+  links() {
+    return this._node.links();
+  }
+  size() {
+    return this._node.size();
+  }
+  data() {
+    return this._node.data();
+  }
+  async verify(key) {
+    if (!this._block) {
+      return new Error("块未加载");
+    }
+    let payload;
+    if (this.prevID() && cid.CID.asCID(this.prevID()) !== null) {
+      // 连接块CID和前一个CID的字节
+      const blockBytes = this._block.cid().bytes;
+      const prevBytes = this.prevID().bytes;
+      payload = new Uint8Array(blockBytes.length + prevBytes.length);
+      payload.set(blockBytes);
+      payload.set(prevBytes, blockBytes.length);
+    } else {
+      payload = this.pubKey();
+    }
+    const ok = await key.verify(payload, this.sig());
+    if (!ok) {
+      return new Error("签名无效");
+    }
+    return;
+  }
+}
+
+exports.CreateRecord = CreateRecord;
+exports.GetRecord = GetRecord;
+exports.Record = Record;
+exports.RecordFromProto = RecordFromProto;
+exports.RecordToProto = RecordToProto;
+exports.logFromProto = logFromProto;
+exports.logToProto = logToProto;