@frak-labs/nexus-sdk 0.0.9 → 0.0.10

package/dist/chunk-3T2FNW6E.cjs

@@ -0,0 +1,100 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkBPFJZRJ6cjs = require('./chunk-BPFJZRJ6.cjs');
+
+// src/core/actions/getUnlockOptions.ts
+function getArticleUnlockOptions(client, { articleId, contentId }) {
+  return client.request({
+    method: "frak_getArticleUnlockOptions",
+    params: [contentId, articleId]
+  });
+}
+
+// src/core/actions/watchUnlockStatus.ts
+function watchUnlockStatus(client, { articleId, contentId }, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToArticleUnlockStatus",
+      params: [contentId, articleId]
+    },
+    callback
+  );
+}
+
+// src/core/actions/watchWalletStatus.ts
+function watchWalletStatus(client, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToWalletStatus"
+    },
+    callback
+  );
+}
+
+// src/core/actions/startUnlock.ts
+async function getStartArticleUnlockUrl(config, params) {
+  const { compressed, compressedHash } = await _chunkBPFJZRJ6cjs.hashAndCompressData.call(void 0, {
+    method: "frak_startArticleUnlock",
+    params
+  });
+  const outputUrl = new URL(config.walletUrl);
+  outputUrl.pathname = "/paywall";
+  outputUrl.searchParams.set("params", encodeURIComponent(compressed));
+  outputUrl.searchParams.set("hash", encodeURIComponent(compressedHash));
+  return outputUrl.toString();
+}
+async function decodeStartUnlockReturn({
+  result,
+  hash
+}) {
+  return _chunkBPFJZRJ6cjs.decompressDataAndCheckHash.call(void 0, {
+    compressed: decodeURIComponent(result),
+    compressedHash: decodeURIComponent(hash)
+  });
+}
+
+// src/core/actions/sendTransaction.ts
+async function sendTransaction(client, { tx, context }) {
+  return await client.request({
+    method: "frak_sendTransaction",
+    params: [tx, context]
+  });
+}
+
+// src/core/actions/siweAuthenticate.ts
+var _siwe = require('viem/siwe');
+async function siweAuthenticate(client, { siwe, context }) {
+  const realStatement = _nullishCoalesce(_optionalChain([siwe, 'optionalAccess', _ => _.statement]), () => ( `I confirm that I want to use my Nexus wallet on: ${client.config.metadata.name}`));
+  const builtSiwe = {
+    ...siwe,
+    statement: realStatement,
+    nonce: _nullishCoalesce(_optionalChain([siwe, 'optionalAccess', _2 => _2.nonce]), () => ( _siwe.generateSiweNonce.call(void 0, ))),
+    uri: _nullishCoalesce(_optionalChain([siwe, 'optionalAccess', _3 => _3.uri]), () => ( `https://${client.config.domain}`)),
+    version: _nullishCoalesce(_optionalChain([siwe, 'optionalAccess', _4 => _4.version]), () => ( "1")),
+    domain: client.config.domain
+  };
+  return await client.request({
+    method: "frak_siweAuthenticate",
+    params: [builtSiwe, context]
+  });
+}
+
+// src/core/actions/sendInteraction.ts
+async function sendInteraction(client, { contentId, interaction, validation }) {
+  return await client.request({
+    method: "frak_sendInteraction",
+    params: [contentId, interaction, validation]
+  });
+}
+
+
+
+
+
+
+
+
+
+
+exports.getArticleUnlockOptions = getArticleUnlockOptions; exports.watchUnlockStatus = watchUnlockStatus; exports.watchWalletStatus = watchWalletStatus; exports.getStartArticleUnlockUrl = getStartArticleUnlockUrl; exports.decodeStartUnlockReturn = decodeStartUnlockReturn; exports.sendTransaction = sendTransaction; exports.siweAuthenticate = siweAuthenticate; exports.sendInteraction = sendInteraction;

package/dist/chunk-72IEHEQX.js

@@ -0,0 +1,48 @@
+// src/core/interactions/pressEncoder.ts
+import { concatHex, pad } from "viem";
+var PressTypeSelector = "0x02";
+var PressActionsSelector = {
+  OpenArticle: "0xc0a24ffb",
+  ReadArticle: "0xd5bd0fbe",
+  Referred: "0x3d1508ad"
+};
+function openArticle({ articleId }) {
+  const interactionData = concatHex([
+    PressActionsSelector.OpenArticle,
+    pad(articleId, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: PressTypeSelector,
+    interactionData
+  };
+}
+function readArticle({ articleId }) {
+  const interactionData = concatHex([
+    PressActionsSelector.ReadArticle,
+    pad(articleId, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: PressTypeSelector,
+    interactionData
+  };
+}
+function referred({ referrer }) {
+  const interactionData = concatHex([
+    PressActionsSelector.Referred,
+    pad(referrer, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: PressTypeSelector,
+    interactionData
+  };
+}
+var PressInteractionEncoder = {
+  openArticle,
+  readArticle,
+  referred
+};
+
+export {
+  PressActionsSelector,
+  PressInteractionEncoder
+};

package/dist/chunk-BPFJZRJ6.cjs

@@ -0,0 +1,152 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/core/types/rpc/error.ts
+var FrakRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+};
+var ClientNotFound = class extends FrakRpcError {
+  constructor() {
+    super(RpcErrorCodes.clientNotConnected, "Client not found");
+  }
+};
+var RpcErrorCodes = {
+  // Standard JSON-RPC 2.0 errors
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  invalidParams: -32602,
+  internalError: -32603,
+  serverError: -32e3,
+  // Frak specific errors (from -32001 to -32099)
+  clientNotConnected: -32001,
+  configError: -32002,
+  corruptedResponse: -32003,
+  clientAborted: -32004,
+  walletNotConnected: -32005,
+  noInteractionSession: -32006
+};
+
+// src/core/utils/compression/compress.ts
+var _asynclzstring = require('async-lz-string');
+var _jssha256 = require('js-sha256');
+async function hashAndCompressData(data) {
+  const validationHash = _jssha256.sha256.call(void 0, JSON.stringify(data));
+  const hashProtectedData = {
+    ...data,
+    validationHash
+  };
+  const compressed = await compressJson(hashProtectedData);
+  const compressedHash = _jssha256.sha256.call(void 0, compressed);
+  return {
+    compressed,
+    compressedHash
+  };
+}
+async function compressJson(data) {
+  return _asynclzstring.compressToBase64.call(void 0, JSON.stringify(data));
+}
+
+// src/core/utils/compression/decompress.ts
+
+
+async function decompressDataAndCheckHash(compressedData) {
+  if (!(_optionalChain([compressedData, 'optionalAccess', _2 => _2.compressed]) && _optionalChain([compressedData, 'optionalAccess', _3 => _3.compressedHash]))) {
+    throw new FrakRpcError(
+      RpcErrorCodes.corruptedResponse,
+      "Missing compressed data"
+    );
+  }
+  const parsedData = await decompressJson(
+    compressedData.compressed
+  );
+  if (!parsedData) {
+    throw new FrakRpcError(
+      RpcErrorCodes.corruptedResponse,
+      "Invalid compressed data"
+    );
+  }
+  if (!_optionalChain([parsedData, 'optionalAccess', _4 => _4.validationHash])) {
+    throw new FrakRpcError(
+      RpcErrorCodes.corruptedResponse,
+      "Missing validation hash"
+    );
+  }
+  const expectedCompressedHash = _jssha256.sha256.call(void 0, compressedData.compressed);
+  if (expectedCompressedHash !== compressedData.compressedHash) {
+    throw new FrakRpcError(
+      RpcErrorCodes.corruptedResponse,
+      "Invalid compressed hash"
+    );
+  }
+  const { validationHash: _, ...rawResultData } = parsedData;
+  const expectedValidationHash = _jssha256.sha256.call(void 0, JSON.stringify(rawResultData));
+  if (expectedValidationHash !== parsedData.validationHash) {
+    throw new FrakRpcError(
+      RpcErrorCodes.corruptedResponse,
+      "Invalid data validation hash"
+    );
+  }
+  return parsedData;
+}
+async function decompressJson(data) {
+  const decompressed = await _asynclzstring.decompressFromBase64.call(void 0, data);
+  try {
+    return JSON.parse(decompressed);
+  } catch (e) {
+    console.error("Invalid compressed data", e);
+    return null;
+  }
+}
+
+// src/core/utils/iframeHelper.ts
+function createIframe({
+  walletBaseUrl
+}) {
+  const alreadyCreatedIFrame = document.querySelector("#nexus-wallet");
+  if (alreadyCreatedIFrame) {
+    return Promise.resolve(void 0);
+  }
+  const iframe = document.createElement("iframe");
+  iframe.name = "nexus-wallet";
+  iframe.id = "nexus-wallet";
+  iframe.style.zIndex = "1000";
+  changeIframeVisibility({ iframe, isVisible: false });
+  document.body.appendChild(iframe);
+  return new Promise((resolve) => {
+    _optionalChain([iframe, 'optionalAccess', _5 => _5.addEventListener, 'call', _6 => _6("load", () => resolve(iframe))]);
+    iframe.src = `${walletBaseUrl}/listener`;
+  });
+}
+function changeIframeVisibility({
+  iframe,
+  isVisible
+}) {
+  if (!isVisible) {
+    iframe.style.width = "0";
+    iframe.style.height = "0";
+    iframe.style.border = "0";
+    iframe.style.position = "fixed";
+    iframe.style.top = "-1000px";
+    iframe.style.left = "-1000px";
+    return;
+  }
+  iframe.style.position = "fixed";
+  iframe.style.top = "0";
+  iframe.style.left = "0";
+  iframe.style.width = "100%";
+  iframe.style.height = "100%";
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.FrakRpcError = FrakRpcError; exports.ClientNotFound = ClientNotFound; exports.RpcErrorCodes = RpcErrorCodes; exports.hashAndCompressData = hashAndCompressData; exports.compressJson = compressJson; exports.decompressDataAndCheckHash = decompressDataAndCheckHash; exports.decompressJson = decompressJson; exports.createIframe = createIframe; exports.changeIframeVisibility = changeIframeVisibility;

package/dist/chunk-ETV4XYOV.cjs

@@ -0,0 +1,7 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+
+
+exports.__publicField = __publicField;

package/dist/{chunk-SZUN32YC.js → chunk-HOX3RRO6.js}

@@ -1,10 +1,13 @@
 import {
-  __publicField,
+  FrakRpcError,
+  RpcErrorCodes,
+  changeIframeVisibility,
   decompressDataAndCheckHash,
-  getIFrameResponseKeyProvider,
-  hashAndCompressData,
-  iFrameRequestKeyProvider
-} from "./chunk-VK7GPKK4.js";
+  hashAndCompressData
+} from "./chunk-TPC5PMRC.js";
+import {
+  __publicField
+} from "./chunk-PKBMQBKP.js";
 
 // src/core/utils/Deferred.ts
 var Deferred = class {
@@ -51,10 +54,16 @@ function createIFrameMessageHandler({
   channelManager
 }) {
   if (typeof window === "undefined") {
-    throw new Error("iframe client should be used in the browser");
+    throw new FrakRpcError(
+      RpcErrorCodes.configError,
+      "iframe client should be used in the browser"
+    );
   }
   if (!iframe.contentWindow) {
-    throw new Error("The iframe does not have a content window");
+    throw new FrakRpcError(
+      RpcErrorCodes.configError,
+      "The iframe does not have a content window"
+    );
   }
   const contentWindow = iframe.contentWindow;
   const isConnected = new Deferred();
@@ -66,7 +75,18 @@ function createIFrameMessageHandler({
       return;
     }
     if ("lifecycle" in event.data) {
-      isConnected.resolve(event.data.lifecycle === "connected");
+      switch (event.data.lifecycle) {
+        case "connected":
+          isConnected.resolve(true);
+          break;
+        case "show":
+        case "hide":
+          changeIframeVisibility({
+            iframe,
+            isVisible: event.data.lifecycle === "show"
+          });
+          break;
+      }
       return;
     }
     const channel = event.data.id;
@@ -106,24 +126,31 @@ function createIFrameNexusClient({
   const request = async (args) => {
     const isConnected = await messageHandler.isConnected;
     if (!isConnected) {
-      throw new Error("The iframe provider isn't connected yet");
+      throw new FrakRpcError(
+        RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
     }
     const result = new Deferred();
-    const resultCompressionKeyProvider = getIFrameResponseKeyProvider(args);
     const channelId = channelManager.createChannel(async (message) => {
-      const decompressed = await decompressDataAndCheckHash(
-        message.data,
-        resultCompressionKeyProvider
-      );
-      result.resolve(decompressed);
+      const decompressed = await decompressDataAndCheckHash(message.data);
+      if (decompressed.error) {
+        result.reject(
+          new FrakRpcError(
+            decompressed.error.code,
+            decompressed.error.message,
+            decompressed.error?.data
+          )
+        );
+      } else {
+        result.resolve(decompressed.result);
+      }
       channelManager.removeChannel(channelId);
     });
-    const compressedMessage = await hashAndCompressData(
-      args,
-      iFrameRequestKeyProvider
-    );
+    const compressedMessage = await hashAndCompressData(args);
     messageHandler.sendEvent({
       id: channelId,
+      // @ts-ignore, todo: idk why the fck it's needed
       topic: args.method,
       data: compressedMessage
     });
@@ -132,20 +159,21 @@ function createIFrameNexusClient({
   const listenerRequest = async (args, callback) => {
     const isConnected = await messageHandler.isConnected;
     if (!isConnected) {
-      throw new Error("The iframe provider isn't connected yet");
+      throw new FrakRpcError(
+        RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
     }
-    const resultCompressionKeyProvider = getIFrameResponseKeyProvider(args);
     const channelId = channelManager.createChannel(async (message) => {
-      const decompressed = await decompressDataAndCheckHash(
-        message.data,
-        resultCompressionKeyProvider
-      );
-      callback(decompressed);
+      console.log("Will try to decompress", { message, args });
+      const decompressed = await decompressDataAndCheckHash(message.data);
+      console.log("Decompressed listening data", { args, decompressed });
+      if (decompressed.result) {
+        callback(decompressed.result);
+      } else {
+      }
     });
-    const compressedMessage = await hashAndCompressData(
-      args,
-      iFrameRequestKeyProvider
-    );
+    const compressedMessage = await hashAndCompressData(args);
     messageHandler.sendEvent({
       id: channelId,
       topic: args.method,

package/dist/chunk-NIFJZD3M.cjs

@@ -0,0 +1,48 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/core/interactions/pressEncoder.ts
+var _viem = require('viem');
+var PressTypeSelector = "0x02";
+var PressActionsSelector = {
+  OpenArticle: "0xc0a24ffb",
+  ReadArticle: "0xd5bd0fbe",
+  Referred: "0x3d1508ad"
+};
+function openArticle({ articleId }) {
+  const interactionData = _viem.concatHex.call(void 0, [
+    PressActionsSelector.OpenArticle,
+    _viem.pad.call(void 0, articleId, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: PressTypeSelector,
+    interactionData
+  };
+}
+function readArticle({ articleId }) {
+  const interactionData = _viem.concatHex.call(void 0, [
+    PressActionsSelector.ReadArticle,
+    _viem.pad.call(void 0, articleId, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: PressTypeSelector,
+    interactionData
+  };
+}
+function referred({ referrer }) {
+  const interactionData = _viem.concatHex.call(void 0, [
+    PressActionsSelector.Referred,
+    _viem.pad.call(void 0, referrer, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: PressTypeSelector,
+    interactionData
+  };
+}
+var PressInteractionEncoder = {
+  openArticle,
+  readArticle,
+  referred
+};
+
+
+
+
+exports.PressActionsSelector = PressActionsSelector; exports.PressInteractionEncoder = PressInteractionEncoder;

package/dist/chunk-PKBMQBKP.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+export {
+  __publicField
+};

package/dist/{chunk-AYZHGMEV.cjs → chunk-SGLR6RFA.cjs}

@@ -4,18 +4,21 @@
 
 
 
-var _chunkZOLP2FJZcjs = require('./chunk-ZOLP2FJZ.cjs');
+var _chunkBPFJZRJ6cjs = require('./chunk-BPFJZRJ6.cjs');
+
+
+var _chunkETV4XYOVcjs = require('./chunk-ETV4XYOV.cjs');
 
 // src/core/utils/Deferred.ts
 var Deferred = class {
   constructor() {
-    _chunkZOLP2FJZcjs.__publicField.call(void 0, this, "_promise");
-    _chunkZOLP2FJZcjs.__publicField.call(void 0, this, "_resolve");
-    _chunkZOLP2FJZcjs.__publicField.call(void 0, this, "_reject");
-    _chunkZOLP2FJZcjs.__publicField.call(void 0, this, "resolve", (value) => {
+    _chunkETV4XYOVcjs.__publicField.call(void 0, this, "_promise");
+    _chunkETV4XYOVcjs.__publicField.call(void 0, this, "_resolve");
+    _chunkETV4XYOVcjs.__publicField.call(void 0, this, "_reject");
+    _chunkETV4XYOVcjs.__publicField.call(void 0, this, "resolve", (value) => {
       _optionalChain([this, 'access', _ => _._resolve, 'optionalCall', _2 => _2(value)]);
     });
-    _chunkZOLP2FJZcjs.__publicField.call(void 0, this, "reject", (reason) => {
+    _chunkETV4XYOVcjs.__publicField.call(void 0, this, "reject", (reason) => {
       _optionalChain([this, 'access', _3 => _3._reject, 'optionalCall', _4 => _4(reason)]);
     });
     this._promise = new Promise((resolve, reject) => {
@@ -51,10 +54,16 @@ function createIFrameMessageHandler({
   channelManager
 }) {
   if (typeof window === "undefined") {
-    throw new Error("iframe client should be used in the browser");
+    throw new (0, _chunkBPFJZRJ6cjs.FrakRpcError)(
+      _chunkBPFJZRJ6cjs.RpcErrorCodes.configError,
+      "iframe client should be used in the browser"
+    );
   }
   if (!iframe.contentWindow) {
-    throw new Error("The iframe does not have a content window");
+    throw new (0, _chunkBPFJZRJ6cjs.FrakRpcError)(
+      _chunkBPFJZRJ6cjs.RpcErrorCodes.configError,
+      "The iframe does not have a content window"
+    );
   }
   const contentWindow = iframe.contentWindow;
   const isConnected = new Deferred();
@@ -66,7 +75,18 @@ function createIFrameMessageHandler({
       return;
     }
     if ("lifecycle" in event.data) {
-      isConnected.resolve(event.data.lifecycle === "connected");
+      switch (event.data.lifecycle) {
+        case "connected":
+          isConnected.resolve(true);
+          break;
+        case "show":
+        case "hide":
+          _chunkBPFJZRJ6cjs.changeIframeVisibility.call(void 0, {
+            iframe,
+            isVisible: event.data.lifecycle === "show"
+          });
+          break;
+      }
       return;
     }
     const channel = event.data.id;
@@ -106,24 +126,31 @@ function createIFrameNexusClient({
   const request = async (args) => {
     const isConnected = await messageHandler.isConnected;
     if (!isConnected) {
-      throw new Error("The iframe provider isn't connected yet");
+      throw new (0, _chunkBPFJZRJ6cjs.FrakRpcError)(
+        _chunkBPFJZRJ6cjs.RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
     }
     const result = new Deferred();
-    const resultCompressionKeyProvider = _chunkZOLP2FJZcjs.getIFrameResponseKeyProvider.call(void 0, args);
     const channelId = channelManager.createChannel(async (message) => {
-      const decompressed = await _chunkZOLP2FJZcjs.decompressDataAndCheckHash.call(void 0, 
-        message.data,
-        resultCompressionKeyProvider
-      );
-      result.resolve(decompressed);
+      const decompressed = await _chunkBPFJZRJ6cjs.decompressDataAndCheckHash.call(void 0, message.data);
+      if (decompressed.error) {
+        result.reject(
+          new (0, _chunkBPFJZRJ6cjs.FrakRpcError)(
+            decompressed.error.code,
+            decompressed.error.message,
+            _optionalChain([decompressed, 'access', _5 => _5.error, 'optionalAccess', _6 => _6.data])
+          )
+        );
+      } else {
+        result.resolve(decompressed.result);
+      }
       channelManager.removeChannel(channelId);
     });
-    const compressedMessage = await _chunkZOLP2FJZcjs.hashAndCompressData.call(void 0, 
-      args,
-      _chunkZOLP2FJZcjs.iFrameRequestKeyProvider
-    );
+    const compressedMessage = await _chunkBPFJZRJ6cjs.hashAndCompressData.call(void 0, args);
     messageHandler.sendEvent({
       id: channelId,
+      // @ts-ignore, todo: idk why the fck it's needed
       topic: args.method,
       data: compressedMessage
     });
@@ -132,20 +159,21 @@ function createIFrameNexusClient({
   const listenerRequest = async (args, callback) => {
     const isConnected = await messageHandler.isConnected;
     if (!isConnected) {
-      throw new Error("The iframe provider isn't connected yet");
+      throw new (0, _chunkBPFJZRJ6cjs.FrakRpcError)(
+        _chunkBPFJZRJ6cjs.RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
     }
-    const resultCompressionKeyProvider = _chunkZOLP2FJZcjs.getIFrameResponseKeyProvider.call(void 0, args);
     const channelId = channelManager.createChannel(async (message) => {
-      const decompressed = await _chunkZOLP2FJZcjs.decompressDataAndCheckHash.call(void 0, 
-        message.data,
-        resultCompressionKeyProvider
-      );
-      callback(decompressed);
+      console.log("Will try to decompress", { message, args });
+      const decompressed = await _chunkBPFJZRJ6cjs.decompressDataAndCheckHash.call(void 0, message.data);
+      console.log("Decompressed listening data", { args, decompressed });
+      if (decompressed.result) {
+        callback(decompressed.result);
+      } else {
+      }
     });
-    const compressedMessage = await _chunkZOLP2FJZcjs.hashAndCompressData.call(void 0, 
-      args,
-      _chunkZOLP2FJZcjs.iFrameRequestKeyProvider
-    );
+    const compressedMessage = await _chunkBPFJZRJ6cjs.hashAndCompressData.call(void 0, args);
     messageHandler.sendEvent({
       id: channelId,
       topic: args.method,