@leofcoin/chain 1.10.22 → 1.11.0

package/exports/browser/{client-DbZBfpG6-CYDyUGUC.js → client-DbZBfpG6-C1cXgvfr.js}

@@ -1,6 +1,6 @@
-import { c as createDebugger, L as LittlePubSub } from './node-browser-BMfelxXV.js';
-import './browser-crypto-CH0ua22L.js';
-import './connection-monitor-DMGAhcC0.js';
+import { c as createDebugger, L as LittlePubSub } from './node-browser-BmyPBkL5.js';
+import './browser-crypto-B_UJguhk.js';
+import './connection-monitor-BzbeYGEt.js';
 import './index-CvKt4UDE.js';
 import './sha2-BKcEJzgd.js';
 
@@ -233,7 +233,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-CCfR9KOM-UO9mzy-j.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-CCfR9KOM-CNWKLusu.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 if (this.#experimentalWebsocket) {
                     client.addEventListener('error', this.onerror);

package/exports/browser/{connection-monitor-DMGAhcC0.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, d as Codec } 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,7 @@ class StateMessage extends FormatInterface {
     if (buffer instanceof StateMessage)
       return buffer;
     const name = "state-message";
-    super(buffer, proto, { name });
+    super(buffer, proto$4, { name });
   }
 }
 
@@ -141,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,
@@ -153,7 +143,35 @@ 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 });
@@ -170,7 +188,8 @@ const guardProviderDiscovery = (peernet) => {
             timeout = setTimeout(() => reject(new Error("provider discovery timed out")), requestTimeout);
           })
         ]);
-        const bytes = result instanceof Uint8Array ? result : new Uint8Array(Object.values(result));
+        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");
@@ -196,7 +215,7 @@ const guardProviderDiscovery = (peernet) => {
   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)) {
+    if (!isChainStore(storeName)) {
       return requestData(hash, store, options);
     }
     const probe = await peernet.prepareMessage(new peernet.protos["peernet-dht"]({ hash, store: storeName }));
@@ -209,7 +228,8 @@ const guardProviderDiscovery = (peernet) => {
       try {
         const fetch = async () => {
           const availability = await peer.request(probe.encoded);
-          const probeBytes = availability instanceof Uint8Array ? availability : new Uint8Array(Object.values(availability));
+          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");

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

@@ -1,6 +1,6 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-BMfelxXV.js';
-import './browser-crypto-CH0ua22L.js';
-import './connection-monitor-DMGAhcC0.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';