web-dc-api 0.0.61 → 0.0.62

package/dist/esm/node_modules/uint8arrays/dist/src/compare.js

@@ -0,0 +1,22 @@
+/**
+ * Can be used with Array.sort to sort and array with Uint8Array entries
+ */
+function compare(a, b) {
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] < b[i]) {
+      return -1;
+    }
+    if (a[i] > b[i]) {
+      return 1;
+    }
+  }
+  if (a.byteLength > b.byteLength) {
+    return 1;
+  }
+  if (a.byteLength < b.byteLength) {
+    return -1;
+  }
+  return 0;
+}
+
+export { compare };

package/dist/esm/node_modules/uint8arrays/dist/src/xor-compare.js

@@ -0,0 +1,19 @@
+/**
+ * Compares two Uint8Arrays representing two xor distances. Returns `-1` if `a`
+ * is a lower distance, `1` if `b` is a lower distance or `0` if the distances
+ * are equal.
+ */
+function xorCompare(a, b) {
+  if (a.byteLength !== b.byteLength) {
+    throw new Error('Inputs should have the same length');
+  }
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] === b[i]) {
+      continue;
+    }
+    return a[i] < b[i] ? -1 : 1;
+  }
+  return 0;
+}
+
+export { xorCompare };

package/dist/esm/node_modules/uint8arrays/dist/src/xor.js

@@ -0,0 +1,18 @@
+import { allocUnsafe } from './alloc.js';
+import { asUint8Array } from './util/as-uint8array.js';
+
+/**
+ * Returns the xor distance between two Uint8Arrays
+ */
+function xor(a, b) {
+  if (a.length !== b.length) {
+    throw new Error('Inputs should have the same length');
+  }
+  const result = allocUnsafe(a.length);
+  for (let i = 0; i < a.length; i++) {
+    result[i] = a[i] ^ b[i];
+  }
+  return asUint8Array(result);
+}
+
+export { xor };

package/dist/esm/node_modules/ulid/dist/index.esm.js

@@ -0,0 +1,91 @@
+import { __require as requireCrypto } from '../stubs/crypto.js';
+
+function createError(message) {
+  const err = new Error(message);
+  err.source = "ulid";
+  return err;
+}
+// These values should NEVER change. If
+// they do, we're no longer making ulids!
+const ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ"; // Crockford's Base32
+const ENCODING_LEN = ENCODING.length;
+const TIME_MAX = Math.pow(2, 48) - 1;
+const TIME_LEN = 10;
+const RANDOM_LEN = 16;
+function randomChar(prng) {
+  let rand = Math.floor(prng() * ENCODING_LEN);
+  if (rand === ENCODING_LEN) {
+    rand = ENCODING_LEN - 1;
+  }
+  return ENCODING.charAt(rand);
+}
+function encodeTime(now, len) {
+  if (isNaN(now)) {
+    throw new Error(now + " must be a number");
+  }
+  if (now > TIME_MAX) {
+    throw createError("cannot encode time greater than " + TIME_MAX);
+  }
+  if (now < 0) {
+    throw createError("time must be positive");
+  }
+  if (Number.isInteger(Number(now)) === false) {
+    throw createError("time must be an integer");
+  }
+  let mod;
+  let str = "";
+  for (; len > 0; len--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING.charAt(mod) + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len, prng) {
+  let str = "";
+  for (; len > 0; len--) {
+    str = randomChar(prng) + str;
+  }
+  return str;
+}
+function detectPrng() {
+  let allowInsecure = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  let root = arguments.length > 1 ? arguments[1] : undefined;
+  if (!root) {
+    root = typeof window !== "undefined" ? window : null;
+  }
+  const browserCrypto = root && (root.crypto || root.msCrypto);
+  if (browserCrypto) {
+    return () => {
+      const buffer = new Uint8Array(1);
+      browserCrypto.getRandomValues(buffer);
+      return buffer[0] / 0xff;
+    };
+  } else {
+    try {
+      const nodeCrypto = requireCrypto();
+      return () => nodeCrypto.randomBytes(1).readUInt8() / 0xff;
+    } catch (e) {}
+  }
+  if (allowInsecure) {
+    try {
+      console.error("secure crypto unusable, falling back to insecure Math.random()!");
+    } catch (e) {}
+    return () => Math.random();
+  }
+  throw createError("secure crypto unusable, insecure Math.random not allowed");
+}
+function factory(currPrng) {
+  if (!currPrng) {
+    currPrng = detectPrng();
+  }
+  return function ulid(seedTime) {
+    if (isNaN(seedTime)) {
+      seedTime = Date.now();
+    }
+    return encodeTime(seedTime, TIME_LEN) + encodeRandom(RANDOM_LEN, currPrng);
+  };
+}
+factory();
+
+export { detectPrng, encodeRandom, encodeTime, factory, randomChar };

package/dist/esm/node_modules/ulid/stubs/crypto.js

@@ -0,0 +1,10 @@
+import { __exports as crypto } from '../../../_virtual/crypto.js';
+
+var hasRequiredCrypto;
+function requireCrypto() {
+  if (hasRequiredCrypto) return crypto;
+  hasRequiredCrypto = 1;
+  return crypto;
+}
+
+export { requireCrypto as __require };

package/dist/esm/node_modules/utf8-byte-length/browser.js

@@ -0,0 +1,47 @@
+var browser;
+var hasRequiredBrowser;
+function requireBrowser() {
+  if (hasRequiredBrowser) return browser;
+  hasRequiredBrowser = 1;
+  function isHighSurrogate(codePoint) {
+    return codePoint >= 0xd800 && codePoint <= 0xdbff;
+  }
+  function isLowSurrogate(codePoint) {
+    return codePoint >= 0xdc00 && codePoint <= 0xdfff;
+  }
+
+  // Truncate string by size in bytes
+  browser = function getByteLength(string) {
+    if (typeof string !== "string") {
+      throw new Error("Input must be string");
+    }
+    var charLength = string.length;
+    var byteLength = 0;
+    var codePoint = null;
+    var prevCodePoint = null;
+    for (var i = 0; i < charLength; i++) {
+      codePoint = string.charCodeAt(i);
+      // handle 4-byte non-BMP chars
+      // low surrogate
+      if (isLowSurrogate(codePoint)) {
+        // when parsing previous hi-surrogate, 3 is added to byteLength
+        if (prevCodePoint != null && isHighSurrogate(prevCodePoint)) {
+          byteLength += 1;
+        } else {
+          byteLength += 3;
+        }
+      } else if (codePoint <= 0x7f) {
+        byteLength += 1;
+      } else if (codePoint >= 0x80 && codePoint <= 0x7ff) {
+        byteLength += 2;
+      } else if (codePoint >= 0x800 && codePoint <= 0xffff) {
+        byteLength += 3;
+      }
+      prevCodePoint = codePoint;
+    }
+    return byteLength;
+  };
+  return browser;
+}
+
+export { requireBrowser as __require };

package/dist/esm/node_modules/util/support/types.js

@@ -1,4 +1,4 @@
-import { __exports as types } from '../../../_virtual/types.js';
+import { __exports as types } from '../../../_virtual/types3.js';
 import { __require as requireIsArguments } from '../../is-arguments/index.js';
 import { __require as requireIsGeneratorFunction } from '../../is-generator-function/index.js';
 import { __require as requireWhichTypedArray } from '../../which-typed-array/index.js';

package/dist/esm/node_modules/util/util.js

@@ -1,4 +1,4 @@
-import { __exports as util } from '../../_virtual/util.js';
+import { __exports as util } from '../../_virtual/util3.js';
 import { __require as requireTypes } from './support/types.js';
 import { __require as requireIsBufferBrowser } from './support/isBufferBrowser.js';
 import { __require as requireInherits_browser } from '../inherits/inherits_browser.js';

package/dist/esm/node_modules/varint/decode.js

@@ -0,0 +1,31 @@
+var decode;
+var hasRequiredDecode;
+function requireDecode() {
+  if (hasRequiredDecode) return decode;
+  hasRequiredDecode = 1;
+  decode = read;
+  var MSB = 0x80,
+    REST = 0x7F;
+  function read(buf, offset) {
+    var res = 0,
+      offset = offset || 0,
+      shift = 0,
+      counter = offset,
+      b,
+      l = buf.length;
+    do {
+      if (counter >= l || shift > 49) {
+        read.bytes = 0;
+        throw new RangeError('Could not decode varint');
+      }
+      b = buf[counter++];
+      res += shift < 28 ? (b & REST) << shift : (b & REST) * Math.pow(2, shift);
+      shift += 7;
+    } while (b >= MSB);
+    read.bytes = counter - offset;
+    return res;
+  }
+  return decode;
+}
+
+export { requireDecode as __require };

package/dist/esm/node_modules/varint/encode.js

@@ -0,0 +1,33 @@
+var encode_1;
+var hasRequiredEncode;
+function requireEncode() {
+  if (hasRequiredEncode) return encode_1;
+  hasRequiredEncode = 1;
+  encode_1 = encode;
+  var MSB = 0x80,
+    MSBALL = -128,
+    INT = Math.pow(2, 31);
+  function encode(num, out, offset) {
+    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+      encode.bytes = 0;
+      throw new RangeError('Could not encode varint');
+    }
+    out = out || [];
+    offset = offset || 0;
+    var oldOffset = offset;
+    while (num >= INT) {
+      out[offset++] = num & 0xFF | MSB;
+      num /= 128;
+    }
+    while (num & MSBALL) {
+      out[offset++] = num & 0xFF | MSB;
+      num >>>= 7;
+    }
+    out[offset] = num | 0;
+    encode.bytes = offset - oldOffset + 1;
+    return out;
+  }
+  return encode_1;
+}
+
+export { requireEncode as __require };

package/dist/esm/node_modules/varint/index.js

@@ -0,0 +1,18 @@
+import { __require as requireEncode } from './encode.js';
+import { __require as requireDecode } from './decode.js';
+import { __require as requireLength } from './length.js';
+
+var varint;
+var hasRequiredVarint;
+function requireVarint() {
+  if (hasRequiredVarint) return varint;
+  hasRequiredVarint = 1;
+  varint = {
+    encode: requireEncode(),
+    decode: requireDecode(),
+    encodingLength: requireLength()
+  };
+  return varint;
+}
+
+export { requireVarint as __require };

package/dist/esm/node_modules/varint/length.js

@@ -0,0 +1,21 @@
+var length;
+var hasRequiredLength;
+function requireLength() {
+  if (hasRequiredLength) return length;
+  hasRequiredLength = 1;
+  var N1 = Math.pow(2, 7);
+  var N2 = Math.pow(2, 14);
+  var N3 = Math.pow(2, 21);
+  var N4 = Math.pow(2, 28);
+  var N5 = Math.pow(2, 35);
+  var N6 = Math.pow(2, 42);
+  var N7 = Math.pow(2, 49);
+  var N8 = Math.pow(2, 56);
+  var N9 = Math.pow(2, 63);
+  length = function (value) {
+    return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+  };
+  return length;
+}
+
+export { requireLength as __require };

package/dist/esm/util/curve25519Encryption.js

@@ -1,6 +1,6 @@
-import { randomBytes } from '@stablelib/random';
-import { box } from 'tweetnacl';
-import { BigInteger } from 'jsbn';
+import { randomBytes } from '../node_modules/@stablelib/random/lib/random.js';
+import { n as naclFastExports } from '../_virtual/nacl-fast.js';
+import { j as jsbnExports } from '../_virtual/index3.js';
 
 // import { webcrypto } from 'crypto'; 
 class Encryption {
@@ -10,7 +10,7 @@ class Encryption {
   // 将字节数组转换为BigInteger  
   static bytesToBigInt(bytes) {
     let hex = Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
-    return new BigInteger(hex, 16);
+    return new jsbnExports.BigInteger(hex, 16);
   }
   // 将BigInteger转换为固定长度的字节数组  
   static bigIntToBytes(bn, length) {
@@ -23,8 +23,8 @@ class Encryption {
   }
   // 扩展欧几里得算法计算模逆  
   static extendedEuclidean(a, b) {
-    if (b.equals(BigInteger.ZERO)) {
-      return [a, new BigInteger("1"), new BigInteger("0")];
+    if (b.equals(jsbnExports.BigInteger.ZERO)) {
+      return [a, new jsbnExports.BigInteger("1"), new jsbnExports.BigInteger("0")];
     }
     const [gcd, x1, y1] = this.extendedEuclidean(b, a.mod(b));
     const x = y1;
@@ -35,18 +35,18 @@ class Encryption {
   static safeModInverse(a, m) {
     // 确保a为正数  
     let positiveA = a.mod(m);
-    if (positiveA.compareTo(BigInteger.ZERO) < 0) {
+    if (positiveA.compareTo(jsbnExports.BigInteger.ZERO) < 0) {
       positiveA = positiveA.add(m);
     }
     // 计算GCD和模逆  
     const [gcd, x] = this.extendedEuclidean(positiveA, m);
     // 检查是否存在模逆  
-    if (!gcd.equals(new BigInteger("1"))) {
+    if (!gcd.equals(new jsbnExports.BigInteger("1"))) {
       throw new Error('Modular inverse does not exist');
     }
     // 确保结果为正数  
     let result = x.mod(m);
-    if (result.compareTo(BigInteger.ZERO) < 0) {
+    if (result.compareTo(jsbnExports.BigInteger.ZERO) < 0) {
       result = result.add(m);
     }
     return result;
@@ -62,7 +62,7 @@ class Encryption {
     bigEndianY[0] &= 127;
     // 3. 转换为BigInteger并计算 u = (1 + y) / (1 - y)  
     const y = this.bytesToBigInt(bigEndianY);
-    const one = new BigInteger("1");
+    const one = new jsbnExports.BigInteger("1");
     // 计算分子 (1 + y)  
     const numerator = one.add(y);
     // 计算分母 (1 - y)  
@@ -90,9 +90,9 @@ class Encryption {
         throw new Error(`Invalid public key length: ${recipientPublicKey.length}`);
       }
       const curve25519PublicKey = Encryption.ed25519PublicKeyToCurve25519(recipientPublicKey); //ed25519.getPublicKey(recipientPublicKey);  
-      const ephemeralKeyPair = box.keyPair();
+      const ephemeralKeyPair = naclFastExports.box.keyPair();
       const nonce = randomBytes(this.NONCE_LENGTH);
-      const encrypted = box(message, nonce, curve25519PublicKey, ephemeralKeyPair.secretKey);
+      const encrypted = naclFastExports.box(message, nonce, curve25519PublicKey, ephemeralKeyPair.secretKey);
       if (!encrypted) {
         throw new Error('Encryption failed');
       }
@@ -122,7 +122,7 @@ class Encryption {
       console.log('\nKey Conversion:');
       console.log('- Ed25519 Public Key:', this.toHex(recipientPublicKey));
       console.log('- Curve25519 Public Key:', this.toHex(curve25519PublicKey));
-      const ephemeralKeyPair = box.keyPair();
+      const ephemeralKeyPair = naclFastExports.box.keyPair();
       console.log('\nEphemeral Key Pair:');
       console.log('- Public Key:', this.toHex(ephemeralKeyPair.publicKey));
       console.log('- Secret Key:', this.toHex(ephemeralKeyPair.secretKey));
@@ -130,7 +130,7 @@ class Encryption {
       console.log('\nNonce:');
       console.log('- Value:', this.toHex(nonce));
       console.log('- Length:', nonce.length);
-      const encrypted = box(message, nonce, curve25519PublicKey, ephemeralKeyPair.secretKey);
+      const encrypted = naclFastExports.box(message, nonce, curve25519PublicKey, ephemeralKeyPair.secretKey);
       if (!encrypted) {
         throw new Error('Encryption failed');
       }
@@ -220,7 +220,7 @@ class Encryption {
         console.log('Converted Curve25519 Private Key:', this.toHex(curve25519PrivateKey));
       }
       // 计算共享密钥  
-      const sharedKey = box.before(ephemeralPublicKey, curve25519PrivateKey);
+      const sharedKey = naclFastExports.box.before(ephemeralPublicKey, curve25519PrivateKey);
       if (!sharedKey) {
         throw new Error('Failed to compute shared key');
       }
@@ -229,7 +229,7 @@ class Encryption {
         console.log('Computed Shared Key:', this.toHex(sharedKey));
       }
       // 解密数据  
-      const decrypted = box.open.after(ciphertext, nonce, sharedKey);
+      const decrypted = naclFastExports.box.open.after(ciphertext, nonce, sharedKey);
       if (!decrypted) {
         throw new Error('Decryption failed - invalid MAC');
       }
@@ -320,7 +320,7 @@ Object.defineProperty(Encryption, "CURVE25519_P", {
   enumerable: true,
   configurable: true,
   writable: true,
-  value: new BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564819949")
+  value: new jsbnExports.BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564819949")
 });
 
 export { Encryption };

package/dist/esm/util/utils.js

@@ -19,10 +19,22 @@ import '../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/CFB.js';
 import '../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/CTR.js';
 import '../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/ECB.js';
 import '../node_modules/jscrypto/es6/lib/algorithm/cipher/mode/OFB.js';
-import '@multiformats/multiaddr';
-import '@libp2p/peer-id';
-import { keys } from '@libp2p/crypto';
-import * as index from '../_virtual/index.js';
+import '../node_modules/multiformats/dist/src/bases/base10.js';
+import '../node_modules/multiformats/dist/src/bases/base16.js';
+import '../node_modules/multiformats/dist/src/bases/base2.js';
+import '../node_modules/multiformats/dist/src/bases/base256emoji.js';
+import '../node_modules/multiformats/dist/src/bases/base36.js';
+import '../node_modules/multiformats/dist/src/bases/base58.js';
+import '../node_modules/multiformats/dist/src/bases/base64.js';
+import '../node_modules/multiformats/dist/src/bases/base8.js';
+import '../node_modules/multiformats/dist/src/bases/identity.js';
+import '../node_modules/multiformats/dist/src/codecs/json.js';
+import '../node_modules/multiformats/dist/src/hashes/sha2-browser.js';
+import '../node_modules/@multiformats/multiaddr/dist/src/convert.js';
+import '../node_modules/@multiformats/multiaddr/dist/src/protocols-table.js';
+import '../node_modules/@multiformats/multiaddr/dist/src/multiaddr.js';
+import * as index from '../_virtual/index2.js';
+import { privateKeyFromRaw } from '../node_modules/@libp2p/crypto/dist/src/keys/index.js';
 
 const {
   Buffer
@@ -118,7 +130,7 @@ async function saveKeyPair(key, keyPair) {
 async function loadKeyPair(key) {
   const privateKey = localStorage.getItem(key);
   if (privateKey) {
-    const keyPair = keys.privateKeyFromRaw(decodeKey(privateKey));
+    const keyPair = privateKeyFromRaw(decodeKey(privateKey));
     return keyPair;
   }
   return null;

package/package.json

@@ -1,7 +1,6 @@
-
 {
   "name": "web-dc-api",
-  "version": "0.0.61",
+  "version": "0.0.62",
   "description": "web相关的dcapi",
   "type": "module",
   "browser": "dist/dc.min.js",
@@ -36,7 +35,6 @@
   "license": "ISC",
   "keywords": {},
   "dependencies": {
-    "grpc-libp2p-client": "^0.0.10",
     "@helia/block-brokers": "4.1.0",
     "@helia/dag-cbor": "^4.0.3",
     "@helia/interface": "4.0.1",
@@ -56,10 +54,12 @@
     "ajv": "^8.17.1",
     "async-mutex": "^0.5.0",
     "blockstore-idb": "^2.0.1",
+    "buffer": "^6.0.3",
     "cids": "^1.1.9",
     "datastore-idb": "^3.0.1",
     "datastore-level": "^11.0.1",
     "google-protobuf": "~3.21.2",
+    "grpc-libp2p-client": "^0.0.10",
     "helia": "5.3.0",
     "interface-ipld-format": "^1.0.1",
     "it-to-buffer": "^4.0.7",
@@ -74,18 +74,12 @@
     "protobufjs": "^7.5.0",
     "tweetnacl": "^1.0.3",
     "uint8arrays": "^5.1.0",
-    "ulid": "^2.3.0",
-    "buffer": "^6.0.3"
+    "ulid": "^2.3.0"
   },
   "directories": {
     "lib": "lib"
   },
   "devDependencies": {
-    "cbor-x": "^1.6.0",
-    "crypto-js": "^4.2.0",
-    "ethers": "^6.14.1",
-    "lodash": "~4.17.0",
-    "mp4box": "^0.5.4",
     "@babel/core": "^7.27.4",
     "@babel/preset-env": "^7.27.2",
     "@rollup/plugin-babel": "^6.0.4",
@@ -97,12 +91,17 @@
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/google-protobuf": "^3.15.12",
     "@types/jsbn": "^1.2.33",
+    "cbor-x": "^1.6.0",
     "core-js": "^3.43.0",
+    "crypto-js": "^4.2.0",
+    "ethers": "^6.14.1",
+    "lodash": "~4.17.0",
+    "mp4box": "^0.5.4",
     "nodemon": "^3.1.9",
     "rollup-plugin-dts": "^6.2.1",
     "typescript": "^5.8.3",
-    "webpack-bundle-analyzer": "^4.10.2",
     "vite": "^7.1.2",
-    "vite-plugin-dts": "^4.5.4"
+    "vite-plugin-dts": "^4.5.4",
+    "webpack-bundle-analyzer": "^4.10.2"
   }
 }