web-dc-api 0.0.58 → 0.0.60

package/dist/esm/modules/util-module.js

@@ -0,0 +1,155 @@
+import { SymmetricKey, Key } from '../implements/threaddb/common/key.js';
+import { CoreModuleName } from '../common/module-system.js';
+import { createLogger } from '../util/logger.js';
+import { UtilManager } from '../implements/util/manager.js';
+import { Errors } from '../common/error.js';
+import { handleIpfsRequest } from '../common/service-worker.js';
+
+const logger = createLogger("UtilModule");
+class UtilModule {
+  constructor() {
+    Object.defineProperty(this, "moduleName", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: CoreModuleName.UTIL
+    });
+    Object.defineProperty(this, "initialized", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: false
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "utilManager", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dcChain", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+  }
+  /**
+   * 初始化工具模块
+   * @param context DC上下文
+   * @returns 是否初始化成功
+   */
+  async initialize(context) {
+    try {
+      this.context = context;
+      this.utilManager = new UtilManager(context);
+      this.initialized = true;
+      return true;
+    } catch (error) {
+      logger.error("工具模块初始化失败:", error);
+      return false;
+    }
+  }
+  /**
+   * 创建对称密钥
+   * @returns 对称密钥
+   */
+  createSymmetricKey() {
+    return SymmetricKey.new();
+  }
+  /**
+   * 创建threaddb密钥
+   * @returns 线程密钥
+   */
+  createThreadKey() {
+    // 生成一个新的密钥，包含两个对称密钥
+    return new Key(SymmetricKey.new(), SymmetricKey.new());
+  }
+  /**
+       * 设置应用信息,发布应用时调用
+       * @param appId string 应用ID
+       * @param domain
+       * @param owner
+       * @param rewarder
+       */
+  async setAppInfo(appId) {
+    let fid = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    let domain = arguments.length > 2 ? arguments[2] : undefined;
+    let owner = arguments.length > 3 ? arguments[3] : undefined;
+    let rewarder = arguments.length > 4 ? arguments[4] : undefined;
+    if (!this.initialized) {
+      return [null, new Error("UtilModule not initialized")];
+    }
+    try {
+      if (!appId) {
+        throw new Error("appId are required");
+      }
+      if (!this.context.publicKey || !this.context.ethAddress) {
+        throw Errors.NO_USER_INFO;
+      }
+      if (!owner || owner.length < 10) {
+        owner = this.context.publicKey.string();
+      }
+      if (!rewarder || rewarder.length < 10) {
+        rewarder = this.context.ethAddress;
+      }
+      const [appInfo, error] = await this.getAppInfo(appId);
+      if (appInfo && !error) {
+        if (appInfo.owner == owner && appInfo.rewarder == rewarder && appInfo.domain == domain && appInfo.fid == fid) {
+          //已经与之前一致
+          return [true, null];
+        }
+      }
+      await this.utilManager.setAppInfo(appId, domain, owner, rewarder, fid);
+      // 假设保存成功
+      return [true, null];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  /**
+  * 获取应用信息
+  * @param appId 应用ID
+  * @returns 应用信息
+  * */
+  async getAppInfo(appId) {
+    if (!this.initialized) {
+      return [null, new Error("UtilModule not initialized")];
+    }
+    try {
+      const appInfo = await this.utilManager.getAppInfo(appId);
+      return [appInfo, null];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  /**
+   * 关闭消息模块
+   */
+  async shutdown() {
+    this.initialized = false;
+  }
+  /**
+      * 处理IPFS请求
+      * @param data 请求数据
+      * @param port 消息端口
+      * @param fileOps 文件操作对象
+      */
+  async handleIpfsRequest(data, port, fileOps) {
+    if (!this.initialized) {
+      return;
+    }
+    try {
+      await handleIpfsRequest(data, port, fileOps);
+    } catch (error) {
+      logger.error("页面处理IPFS请求失败:", error);
+    }
+  }
+}
+
+export { UtilModule };

package/dist/esm/node_modules/@chainsafe/is-ip/lib/is-ip.js

@@ -0,0 +1,12 @@
+import { parseIPv4, parseIPv6 } from './parse.js';
+
+/** Check if `input` is IPv4. */
+function isIPv4(input) {
+  return Boolean(parseIPv4(input));
+}
+/** Check if `input` is IPv6. */
+function isIPv6(input) {
+  return Boolean(parseIPv6(input));
+}
+
+export { isIPv4, isIPv6 };

package/dist/esm/node_modules/@chainsafe/is-ip/lib/parse.js

@@ -0,0 +1,45 @@
+import { Parser } from './parser.js';
+
+// See https://stackoverflow.com/questions/166132/maximum-length-of-the-textual-representation-of-an-ipv6-address
+const MAX_IPV6_LENGTH = 45;
+const MAX_IPV4_LENGTH = 15;
+const parser = new Parser();
+/** Parse `input` into IPv4 bytes. */
+function parseIPv4(input) {
+  if (input.length > MAX_IPV4_LENGTH) {
+    return undefined;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+/** Parse `input` into IPv6 bytes. */
+function parseIPv6(input) {
+  // strip zone index if it is present
+  if (input.includes("%")) {
+    input = input.split("%")[0];
+  }
+  if (input.length > MAX_IPV6_LENGTH) {
+    return undefined;
+  }
+  return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+/** Parse `input` into IPv4 or IPv6 bytes. */
+function parseIP(input) {
+  let mapIPv4ToIPv6 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+  // strip zone index if it is present
+  if (input.includes("%")) {
+    input = input.split("%")[0];
+  }
+  if (input.length > MAX_IPV6_LENGTH) {
+    return undefined;
+  }
+  const addr = parser.new(input).parseWith(() => parser.readIPAddr());
+  if (!addr) {
+    return undefined;
+  }
+  if (mapIPv4ToIPv6 && addr.length === 4) {
+    return Uint8Array.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, addr[0], addr[1], addr[2], addr[3]]);
+  }
+  return addr;
+}
+
+export { parseIP, parseIPv4, parseIPv6 };

package/dist/esm/node_modules/@chainsafe/is-ip/lib/parser.js

@@ -0,0 +1,200 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+class Parser {
+  index = 0;
+  input = "";
+  new(input) {
+    this.index = 0;
+    this.input = input;
+    return this;
+  }
+  /** Run a parser, and restore the pre-parse state if it fails. */
+  readAtomically(fn) {
+    const index = this.index;
+    const result = fn();
+    if (result === undefined) {
+      this.index = index;
+    }
+    return result;
+  }
+  /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
+  parseWith(fn) {
+    const result = fn();
+    if (this.index !== this.input.length) {
+      return undefined;
+    }
+    return result;
+  }
+  /** Peek the next character from the input */
+  peekChar() {
+    if (this.index >= this.input.length) {
+      return undefined;
+    }
+    return this.input[this.index];
+  }
+  /** Read the next character from the input */
+  readChar() {
+    if (this.index >= this.input.length) {
+      return undefined;
+    }
+    return this.input[this.index++];
+  }
+  /** Read the next character from the input if it matches the target. */
+  readGivenChar(target) {
+    return this.readAtomically(() => {
+      const char = this.readChar();
+      if (char !== target) {
+        return undefined;
+      }
+      return char;
+    });
+  }
+  /**
+   * Helper for reading separators in an indexed loop. Reads the separator
+   * character iff index > 0, then runs the parser. When used in a loop,
+   * the separator character will only be read on index > 0 (see
+   * readIPv4Addr for an example)
+   */
+  readSeparator(sep, index, inner) {
+    return this.readAtomically(() => {
+      if (index > 0) {
+        if (this.readGivenChar(sep) === undefined) {
+          return undefined;
+        }
+      }
+      return inner();
+    });
+  }
+  /**
+   * Read a number off the front of the input in the given radix, stopping
+   * at the first non-digit character or eof. Fails if the number has more
+   * digits than max_digits or if there is no number.
+   */
+  readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
+    return this.readAtomically(() => {
+      let result = 0;
+      let digitCount = 0;
+      const leadingChar = this.peekChar();
+      if (leadingChar === undefined) {
+        return undefined;
+      }
+      const hasLeadingZero = leadingChar === "0";
+      const maxValue = 2 ** (8 * maxBytes) - 1;
+      // eslint-disable-next-line no-constant-condition
+      while (true) {
+        const digit = this.readAtomically(() => {
+          const char = this.readChar();
+          if (char === undefined) {
+            return undefined;
+          }
+          const num = Number.parseInt(char, radix);
+          if (Number.isNaN(num)) {
+            return undefined;
+          }
+          return num;
+        });
+        if (digit === undefined) {
+          break;
+        }
+        result *= radix;
+        result += digit;
+        if (result > maxValue) {
+          return undefined;
+        }
+        digitCount += 1;
+        if (maxDigits !== undefined) {
+          if (digitCount > maxDigits) {
+            return undefined;
+          }
+        }
+      }
+      if (digitCount === 0) {
+        return undefined;
+      } else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+        return undefined;
+      } else {
+        return result;
+      }
+    });
+  }
+  /** Read an IPv4 address. */
+  readIPv4Addr() {
+    return this.readAtomically(() => {
+      const out = new Uint8Array(4);
+      for (let i = 0; i < out.length; i++) {
+        const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+        if (ix === undefined) {
+          return undefined;
+        }
+        out[i] = ix;
+      }
+      return out;
+    });
+  }
+  /** Read an IPv6 Address. */
+  readIPv6Addr() {
+    /**
+     * Read a chunk of an IPv6 address into `groups`. Returns the number
+     * of groups read, along with a bool indicating if an embedded
+     * trailing IPv4 address was read. Specifically, read a series of
+     * colon-separated IPv6 groups (0x0000 - 0xFFFF), with an optional
+     * trailing embedded IPv4 address.
+     */
+    const readGroups = groups => {
+      for (let i = 0; i < groups.length / 2; i++) {
+        const ix = i * 2;
+        // Try to read a trailing embedded IPv4 address. There must be at least 4 groups left.
+        if (i < groups.length - 3) {
+          const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+          if (ipv4 !== undefined) {
+            groups[ix] = ipv4[0];
+            groups[ix + 1] = ipv4[1];
+            groups[ix + 2] = ipv4[2];
+            groups[ix + 3] = ipv4[3];
+            return [ix + 4, true];
+          }
+        }
+        const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+        if (group === undefined) {
+          return [ix, false];
+        }
+        groups[ix] = group >> 8;
+        groups[ix + 1] = group & 255;
+      }
+      return [groups.length, false];
+    };
+    return this.readAtomically(() => {
+      // Read the front part of the address; either the whole thing, or up to the first ::
+      const head = new Uint8Array(16);
+      const [headSize, headIp4] = readGroups(head);
+      if (headSize === 16) {
+        return head;
+      }
+      // IPv4 part is not allowed before `::`
+      if (headIp4) {
+        return undefined;
+      }
+      // Read `::` if previous code parsed less than 8 groups.
+      // `::` indicates one or more groups of 16 bits of zeros.
+      if (this.readGivenChar(":") === undefined) {
+        return undefined;
+      }
+      if (this.readGivenChar(":") === undefined) {
+        return undefined;
+      }
+      // Read the back part of the address. The :: must contain at least one
+      // set of zeroes, so our max length is 7.
+      const tail = new Uint8Array(14);
+      const limit = 16 - (headSize + 2);
+      const [tailSize] = readGroups(tail.subarray(0, limit));
+      // Concat the head and tail of the IP address
+      head.set(tail.subarray(0, tailSize), 16 - tailSize);
+      return head;
+    });
+  }
+  /** Read an IP Address, either IPv4 or IPv6. */
+  readIPAddr() {
+    return this.readIPv4Addr() ?? this.readIPv6Addr();
+  }
+}
+
+export { Parser };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/constants.js

@@ -0,0 +1,5 @@
+const NOISE_MSG_MAX_LENGTH_BYTES = 65535;
+const NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG = NOISE_MSG_MAX_LENGTH_BYTES - 16;
+const DUMP_SESSION_KEYS = Boolean(globalThis.process?.env?.DUMP_SESSION_KEYS);
+
+export { DUMP_SESSION_KEYS, NOISE_MSG_MAX_LENGTH_BYTES, NOISE_MSG_MAX_LENGTH_BYTES_WITHOUT_TAG };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/crypto/index.browser.js

@@ -0,0 +1,5 @@
+import { pureJsCrypto } from './js.js';
+
+const defaultCrypto = pureJsCrypto;
+
+export { defaultCrypto };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/crypto/js.js

@@ -0,0 +1,45 @@
+import { chacha20poly1305 } from '../../../../../@noble/ciphers/esm/chacha.js';
+import { x25519 } from '../../../../../@noble/curves/esm/ed25519.js';
+import { extract, expand } from '../../../../../@noble/hashes/esm/hkdf.js';
+import { sha256 } from '../../../../../@noble/hashes/esm/sha256.js';
+
+const pureJsCrypto = {
+  hashSHA256(data) {
+    return sha256(data.subarray());
+  },
+  getHKDF(ck, ikm) {
+    const prk = extract(sha256, ikm, ck);
+    const okmU8Array = expand(sha256, prk, undefined, 96);
+    const okm = okmU8Array;
+    const k1 = okm.subarray(0, 32);
+    const k2 = okm.subarray(32, 64);
+    const k3 = okm.subarray(64, 96);
+    return [k1, k2, k3];
+  },
+  generateX25519KeyPair() {
+    const secretKey = x25519.utils.randomPrivateKey();
+    const publicKey = x25519.getPublicKey(secretKey);
+    return {
+      publicKey,
+      privateKey: secretKey
+    };
+  },
+  generateX25519KeyPairFromSeed(seed) {
+    const publicKey = x25519.getPublicKey(seed);
+    return {
+      publicKey,
+      privateKey: seed
+    };
+  },
+  generateX25519SharedKey(privateKey, publicKey) {
+    return x25519.getSharedSecret(privateKey.subarray(), publicKey.subarray());
+  },
+  chaCha20Poly1305Encrypt(plaintext, nonce, ad, k) {
+    return chacha20poly1305(k, nonce, ad).encrypt(plaintext.subarray());
+  },
+  chaCha20Poly1305Decrypt(ciphertext, nonce, ad, k, dst) {
+    return chacha20poly1305(k, nonce, ad).decrypt(ciphertext.subarray(), dst);
+  }
+};
+
+export { pureJsCrypto };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/crypto.js

@@ -0,0 +1,12 @@
+function wrapCrypto(crypto) {
+  return {
+    generateKeypair: crypto.generateX25519KeyPair,
+    dh: (keypair, publicKey) => crypto.generateX25519SharedKey(keypair.privateKey, publicKey).subarray(0, 32),
+    encrypt: crypto.chaCha20Poly1305Encrypt,
+    decrypt: crypto.chaCha20Poly1305Decrypt,
+    hash: crypto.hashSHA256,
+    hkdf: crypto.getHKDF
+  };
+}
+
+export { wrapCrypto };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/encoder.js

@@ -0,0 +1,22 @@
+import { allocUnsafe } from '../../../../uint8arrays/dist/src/alloc.js';
+
+const uint16BEEncode = value => {
+  const target = allocUnsafe(2);
+  target[0] = value >> 8;
+  target[1] = value;
+  return target;
+};
+uint16BEEncode.bytes = 2;
+const uint16BEDecode = data => {
+  if (data.length < 2) throw RangeError('Could not decode int16BE');
+  if (data instanceof Uint8Array) {
+    let value = 0;
+    value += data[0] << 8;
+    value += data[1];
+    return value;
+  }
+  return data.getUint16(0);
+};
+uint16BEDecode.bytes = 2;
+
+export { uint16BEDecode, uint16BEEncode };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/errors.js

@@ -0,0 +1,11 @@
+class InvalidCryptoExchangeError extends Error {
+  code;
+  constructor() {
+    let message = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'Invalid crypto exchange';
+    super(message);
+    this.code = InvalidCryptoExchangeError.code;
+  }
+  static code = 'ERR_INVALID_CRYPTO_EXCHANGE';
+}
+
+export { InvalidCryptoExchangeError };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/index.js

@@ -0,0 +1,45 @@
+import { Noise } from './noise.js';
+
+/**
+ * @packageDocumentation
+ *
+ * This repository contains TypeScript implementation of noise protocol, an encryption protocol used in libp2p.
+ *
+ * ## Usage
+ *
+ * Install with `yarn add @chainsafe/libp2p-noise` or `npm i @chainsafe/libp2p-noise`.
+ *
+ * Example of using default noise configuration and passing it to the libp2p config:
+ *
+ * ```ts
+ * import {createLibp2p} from "libp2p"
+ * import {noise} from "@chainsafe/libp2p-noise"
+ *
+ * //custom noise configuration, pass it instead of `noise()`
+ * //x25519 private key
+ * const n = noise({ staticNoiseKey });
+ *
+ * const libp2p = await createLibp2p({
+ *   connectionEncrypters: [noise()],
+ *   //... other options
+ * })
+ * ```
+ *
+ * See the [NoiseInit](https://github.com/ChainSafe/js-libp2p-noise/blob/master/src/noise.ts#L22-L30) interface for noise configuration options.
+ *
+ * ## API
+ *
+ * This module exposes an implementation of the [ConnectionEncrypter](https://libp2p.github.io/js-libp2p/interfaces/_libp2p_interface.ConnectionEncrypter.html) interface.
+ *
+ * ## Bring your own crypto
+ *
+ * You can provide a custom crypto implementation (instead of the default, based on [@noble](https://paulmillr.com/noble/)) by adding a `crypto` field to the init argument passed to the `Noise` factory.
+ *
+ * The implementation must conform to the `ICryptoInterface`, defined in <https://github.com/ChainSafe/js-libp2p-noise/blob/master/src/crypto.ts>
+ */
+function noise() {
+  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return components => new Noise(components, init);
+}
+
+export { noise };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/logger.js

@@ -0,0 +1,54 @@
+import { toString } from '../../../../uint8arrays/dist/src/to-string.js';
+import { DUMP_SESSION_KEYS } from './constants.js';
+
+function logLocalStaticKeys(s, keyLogger) {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return;
+  }
+  if (s) {
+    keyLogger(`LOCAL_STATIC_PUBLIC_KEY ${toString(s.publicKey, 'hex')}`);
+    keyLogger(`LOCAL_STATIC_PRIVATE_KEY ${toString(s.privateKey, 'hex')}`);
+  } else {
+    keyLogger('Missing local static keys.');
+  }
+}
+function logLocalEphemeralKeys(e, keyLogger) {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return;
+  }
+  if (e) {
+    keyLogger(`LOCAL_PUBLIC_EPHEMERAL_KEY ${toString(e.publicKey, 'hex')}`);
+    keyLogger(`LOCAL_PRIVATE_EPHEMERAL_KEY ${toString(e.privateKey, 'hex')}`);
+  } else {
+    keyLogger('Missing local ephemeral keys.');
+  }
+}
+function logRemoteStaticKey(rs, keyLogger) {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return;
+  }
+  if (rs) {
+    keyLogger(`REMOTE_STATIC_PUBLIC_KEY ${toString(rs.subarray(), 'hex')}`);
+  } else {
+    keyLogger('Missing remote static public key.');
+  }
+}
+function logRemoteEphemeralKey(re, keyLogger) {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return;
+  }
+  if (re) {
+    keyLogger(`REMOTE_EPHEMERAL_PUBLIC_KEY ${toString(re.subarray(), 'hex')}`);
+  } else {
+    keyLogger('Missing remote ephemeral keys.');
+  }
+}
+function logCipherState(cs1, cs2, keyLogger) {
+  if (!keyLogger.enabled || !DUMP_SESSION_KEYS) {
+    return;
+  }
+  keyLogger(`CIPHER_STATE_1 ${cs1.n.getUint64()} ${cs1.k && toString(cs1.k, 'hex')}`);
+  keyLogger(`CIPHER_STATE_2 ${cs2.n.getUint64()} ${cs2.k && toString(cs2.k, 'hex')}`);
+}
+
+export { logCipherState, logLocalEphemeralKeys, logLocalStaticKeys, logRemoteEphemeralKey, logRemoteStaticKey };

package/dist/esm/node_modules/@chainsafe/libp2p-noise/dist/src/metrics.js

@@ -0,0 +1,21 @@
+function registerMetrics(metrics) {
+  return {
+    xxHandshakeSuccesses: metrics.registerCounter('libp2p_noise_xxhandshake_successes_total', {
+      help: 'Total count of noise xxHandshakes successes_'
+    }),
+    xxHandshakeErrors: metrics.registerCounter('libp2p_noise_xxhandshake_error_total', {
+      help: 'Total count of noise xxHandshakes errors'
+    }),
+    encryptedPackets: metrics.registerCounter('libp2p_noise_encrypted_packets_total', {
+      help: 'Total count of noise encrypted packets successfully'
+    }),
+    decryptedPackets: metrics.registerCounter('libp2p_noise_decrypted_packets_total', {
+      help: 'Total count of noise decrypted packets'
+    }),
+    decryptErrors: metrics.registerCounter('libp2p_noise_decrypt_errors_total', {
+      help: 'Total count of noise decrypt errors'
+    })
+  };
+}
+
+export { registerMetrics };