@leofcoin/chain 1.10.21 → 1.10.22

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

@@ -1,4 +1,4 @@
-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 { F as FormatInterface, o as proto$2, q as proto$3, r as encodeFrames, s as decodeFrames, t as proto$4, d as Codec } from './browser-crypto-CH0ua22L.js';
 
 class ValidatorMessage extends FormatInterface {
   get messageName() {
@@ -90,6 +90,29 @@ class StateMessage extends FormatInterface {
   }
 }
 
+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;
+  }
+}
+
 var networks = {
   leofcoin: {
     mainnet: {
@@ -130,6 +153,92 @@ const DEFAULT_NODE_OPTIONS = {
 
 const INITIAL_RECONNECT_DELAY = 5e3;
 const MAX_RECONNECT_DELAY = 3e4;
+const guardProviderDiscovery = (peernet) => {
+  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);
+          })
+        ]);
+        const bytes = result instanceof Uint8Array ? result : new Uint8Array(Object.values(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 (!["block", "transaction", "transactionPool"].includes(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);
+          const probeBytes = availability instanceof Uint8Array ? availability : new Uint8Array(Object.values(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 +560,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-C6SJ0ZYW.js}

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