@leofcoin/chain 1.10.21 → 1.11.0

package/exports/browser/{connection-monitor-D-krNiRH.js → connection-monitor-BzbeYGEt.js}

@@ -1,6 +1,6 @@
-import { F as FormatInterface, o as proto$2, q as proto$3, r as encodeFrames, s as decodeFrames, t as proto$4 } from './browser-crypto-CH0ua22L.js';
+import { B as BinaryFormat, t as proto, u as proto$1, w as encodeFrames, x as decodeFrames, y as proto$2, z as proto$3, A as proto$4, C as Codec } from './browser-crypto-B_UJguhk.js';
 
-class ValidatorMessage extends FormatInterface {
+class ValidatorMessage extends BinaryFormat {
   get messageName() {
     return "ValidatorMessage";
   }
@@ -8,11 +8,11 @@ class ValidatorMessage extends FormatInterface {
     if (buffer instanceof ValidatorMessage)
       return buffer;
     const name = "validator-message";
-    super(buffer, proto$2, { name });
+    super(buffer, proto, { name });
   }
 }
 
-class BlockMessage extends FormatInterface {
+class BlockMessage extends BinaryFormat {
   get messageName() {
     return "BlockMessage";
   }
@@ -20,7 +20,7 @@ class BlockMessage extends FormatInterface {
     if (buffer instanceof BlockMessage)
       return buffer;
     const name = "block-message";
-    super(buffer, proto$3, { name });
+    super(buffer, proto$1, { name });
   }
   encode(decoded) {
     decoded = decoded || this.decoded;
@@ -39,17 +39,12 @@ class BlockMessage extends FormatInterface {
   decode(encoded) {
     encoded = encoded || this.encoded;
     super.decode(encoded);
-    this.decoded.validators = decodeFrames(this.decoded.validators, 0, { canonical: false }).map((validator) => new ValidatorMessage(validator).decoded);
+    this.decoded.validators = decodeFrames(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
     return this.decoded;
   }
 }
 
-var proto$1 = {
-  up: Number(),
-  down: Number()
-};
-
-class BWMessage extends FormatInterface {
+class BWMessage extends BinaryFormat {
   get messageName() {
     return "BWMessage";
   }
@@ -57,11 +52,11 @@ class BWMessage extends FormatInterface {
     if (buffer instanceof BWMessage)
       return buffer;
     const name = "bw-message";
-    super(buffer, proto$1, { name });
+    super(buffer, proto$2, { name });
   }
 }
 
-class LastBlockMessage extends FormatInterface {
+class LastBlockMessage extends BinaryFormat {
   get messageName() {
     return "LastBlockMessage";
   }
@@ -69,16 +64,11 @@ class LastBlockMessage extends FormatInterface {
     if (buffer instanceof LastBlockMessage)
       return buffer;
     const name = "last-block-message";
-    super(buffer, proto$4, { name });
+    super(buffer, proto$3, { name });
   }
 }
 
-var proto = {
-  lastblock: Object(),
-  values: Object()
-};
-
-class StateMessage extends FormatInterface {
+class StateMessage extends BinaryFormat {
   get messageName() {
     return "StateMessage";
   }
@@ -86,7 +76,30 @@ class StateMessage extends FormatInterface {
     if (buffer instanceof StateMessage)
       return buffer;
     const name = "state-message";
-    super(buffer, proto, { name });
+    super(buffer, proto$4, { name });
+  }
+}
+
+const limit = 1800;
+const transactionLimit = 2500;
+const requestTimeout = 3e4;
+const syncTimeout = 3e4;
+class Protocol {
+  constructor(config) {
+    this.resolveTimeout = 1e4;
+    if (config?.resolveTimeout) this.resolveTimeout = config.resolveTimeout;
+  }
+  get limit() {
+    return limit;
+  }
+  get transactionLimit() {
+    return transactionLimit;
+  }
+  get requestTimeout() {
+    return requestTimeout;
+  }
+  get syncTimeout() {
+    return syncTimeout;
   }
 }
 
@@ -118,7 +131,7 @@ var networks$1 = /*#__PURE__*/Object.freeze({
     default: networks
 });
 
-const PROTOCOL_VERSION = "0.4.0";
+const PROTOCOL_VERSION = "0.5.0";
 const REACHED_ONE_ZERO_ZERO = false;
 const DEFAULT_NODE_OPTIONS = {
   autoStart: false,
@@ -130,6 +143,122 @@ const DEFAULT_NODE_OPTIONS = {
 
 const INITIAL_RECONNECT_DELAY = 5e3;
 const MAX_RECONNECT_DELAY = 3e4;
+const isChainStore = (store) => store === "block" || store === "transaction" || store === "transactionPool";
+const guardProviderDiscovery = (peernet) => {
+  const handleData = peernet.handleData.bind(peernet);
+  peernet.handleData = async (peer, id, proto) => {
+    const { hash, store: storeName } = proto.decoded;
+    if (!isChainStore(storeName)) return handleData(peer, id, proto);
+    let data = new Uint8Array();
+    try {
+      const store = globalThis[`${storeName}Store`];
+      if (store && !("private" in store && store.private) && await store.has(hash)) {
+        const bytes = await store.get(hash);
+        if (!(bytes instanceof Uint8Array) || bytes.length === 0) {
+          throw new Error("local content is unavailable");
+        }
+        data = bytes;
+      } else {
+        console.warn(`Requested content unavailable in ${storeName}: ${hash}`);
+      }
+    } catch (error) {
+      console.error(`Local chain data read failed in ${storeName}: ${hash}`, error);
+    }
+    try {
+      const response = new peernet.protos["peernet-data-response"]({ hash, data });
+      const message = await peernet.prepareMessage(response);
+      await peernet.sendMessage(peer, id, message.encoded);
+    } catch (error) {
+      console.error(`Incoming chain data response failed in ${storeName}: ${hash}`, error);
+    }
+  };
+  peernet.walk = async (hash) => {
+    if (!hash) throw new Error("hash expected for provider discovery");
+    const request = new peernet.protos["peernet-dht"]({ hash });
+    const message = await peernet.prepareMessage(request);
+    const connections = peernet.connections;
+    const requests = Object.entries(connections).filter(
+      ([id, peer]) => id !== peernet.id && peer.connected
+    ).map(async ([id, peer]) => {
+      let timeout;
+      try {
+        const result = await Promise.race([
+          peer.request(message.encoded),
+          new Promise((_, reject) => {
+            timeout = setTimeout(() => reject(new Error("provider discovery timed out")), requestTimeout);
+          })
+        ]);
+        if (!(result instanceof Uint8Array)) throw new TypeError("Peer response must be Uint8Array");
+        const bytes = result;
+        if (new Codec(bytes).name !== "peernet-dht-response") throw new Error("invalid provider response codec");
+        const response = new peernet.protos["peernet-dht-response"](bytes).decoded;
+        if (response.hash !== hash) throw new Error("provider response hash mismatch");
+        if (!response.has) throw new Error("peer does not provide content");
+        peernet.dht.addProvider({ id, address: peer.remoteAddress }, hash);
+      } catch (error) {
+        if (error.message !== "peer does not provide content") {
+          console.warn(`Provider discovery failed for ${id}:`, error?.message ?? error);
+        }
+        throw error;
+      } finally {
+        clearTimeout(timeout);
+      }
+    });
+    if (requests.length === 0) return;
+    try {
+      await Promise.any(requests);
+    } catch (error) {
+      if (!(error instanceof AggregateError)) throw error;
+      console.warn(`No connected provider found for ${hash}`);
+    }
+  };
+  const requestData = peernet.requestData.bind(peernet);
+  peernet.requestData = async (hash, store, options) => {
+    const storeName = typeof store === "string" ? store : store?.name;
+    if (!isChainStore(storeName)) {
+      return requestData(hash, store, options);
+    }
+    const probe = await peernet.prepareMessage(new peernet.protos["peernet-dht"]({ hash, store: storeName }));
+    const request = await peernet.prepareMessage(new peernet.protos["peernet-data"]({ hash, store: storeName }));
+    const connections = peernet.connections;
+    const requests = Object.entries(connections).filter(
+      ([id, peer]) => id !== peernet.id && peer.connected
+    ).map(async ([id, peer]) => {
+      let timeout;
+      try {
+        const fetch = async () => {
+          const availability = await peer.request(probe.encoded);
+          if (!(availability instanceof Uint8Array)) throw new TypeError("Peer response must be Uint8Array");
+          const probeBytes = availability;
+          if (new Codec(probeBytes).name !== "peernet-dht-response") throw new Error("invalid provider response codec");
+          const provider = new peernet.protos["peernet-dht-response"](probeBytes).decoded;
+          if (provider.hash !== hash || !provider.has) throw new Error("peer does not provide content in requested store");
+          const result = await peer.request(request.encoded);
+          const bytes = result instanceof Uint8Array ? result : new Uint8Array(Object.values(result));
+          if (new Codec(bytes).name !== "peernet-data-response") throw new Error("invalid data response codec");
+          const response = new peernet.protos["peernet-data-response"](bytes).decoded;
+          if (response.hash !== hash || !(response.data instanceof Uint8Array) || response.data.length === 0) {
+            throw new Error("invalid content response");
+          }
+          return response.data;
+        };
+        return await Promise.race([
+          fetch(),
+          new Promise((_, reject) => {
+            timeout = setTimeout(() => reject(new Error(`content request timed out for ${id}`)), requestTimeout);
+          })
+        ]);
+      } finally {
+        clearTimeout(timeout);
+      }
+    });
+    try {
+      return await Promise.any(requests);
+    } catch (error) {
+      throw new Error(`Content unavailable in ${storeName}: ${hash}`, { cause: error });
+    }
+  };
+};
 const isSendablePeer = (peer) => {
   if (!peer || typeof peer !== "object") return false;
   const candidate = peer;
@@ -451,4 +580,4 @@ class ConnectionMonitor {
   }
 }
 
-export { BlockMessage as B, ConnectionMonitor as C, DEFAULT_NODE_OPTIONS as D, LastBlockMessage as L, PROTOCOL_VERSION as P, REACHED_ONE_ZERO_ZERO as R, StateMessage as S, ValidatorMessage as V, BWMessage as a, guardPeerMessages as g };
+export { BlockMessage as B, ConnectionMonitor as C, DEFAULT_NODE_OPTIONS as D, LastBlockMessage as L, Protocol as P, REACHED_ONE_ZERO_ZERO as R, StateMessage as S, ValidatorMessage as V, PROTOCOL_VERSION as a, BWMessage as b, guardProviderDiscovery as c, guardPeerMessages as g };

package/exports/browser/{index-dTQVgkpf-DOL2rIjp.js → index-dTQVgkpf-CkoAiRNX.js}

@@ -1,6 +1,6 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-Ha4Lvntj.js';
-import './browser-crypto-CH0ua22L.js';
-import './connection-monitor-D-krNiRH.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-BmyPBkL5.js';
+import './browser-crypto-B_UJguhk.js';
+import './connection-monitor-BzbeYGEt.js';
 import './index-CvKt4UDE.js';
 import './sha2-BKcEJzgd.js';