@frak-labs/nexus-sdk 0.0.10 → 0.0.11

package/dist/chunk-5CFD5FM2.js

@@ -0,0 +1,86 @@
+// src/core/actions/watchWalletStatus.ts
+function watchWalletStatus(client, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToWalletStatus"
+    },
+    callback
+  );
+}
+
+// src/core/utils/computeContentId.ts
+import { keccak256, toHex } from "viem";
+function computeContentId({ domain }) {
+  return keccak256(toHex(domain));
+}
+
+// src/core/actions/sendInteraction.ts
+async function sendInteraction(client, { contentId, interaction, validation }) {
+  const cId = contentId ?? computeContentId(client.config);
+  return await client.request({
+    method: "frak_sendInteraction",
+    params: [cId, interaction, validation]
+  });
+}
+
+// src/core/actions/displayModal.ts
+async function displayModal(client, { steps, metadata }) {
+  return await client.request({
+    method: "frak_displayModal",
+    params: [steps, client.config.metadata.name, metadata]
+  });
+}
+
+// src/core/actions/openSso.ts
+async function openSso(client, args) {
+  const { metadata } = client.config;
+  await client.request({
+    method: "frak_sso",
+    params: [args, metadata.name, metadata.css]
+  });
+}
+
+// src/core/actions/wrapper/siweAuthenticate.ts
+import { generateSiweNonce } from "viem/siwe";
+async function siweAuthenticate(client, { siwe, metadata }) {
+  const realStatement = siwe?.statement ?? `I confirm that I want to use my Nexus wallet on: ${client.config.metadata.name}`;
+  const builtSiwe = {
+    ...siwe,
+    statement: realStatement,
+    nonce: siwe?.nonce ?? generateSiweNonce(),
+    uri: siwe?.uri ?? `https://${client.config.domain}`,
+    version: siwe?.version ?? "1",
+    domain: client.config.domain
+  };
+  const result = await displayModal(client, {
+    metadata,
+    steps: {
+      login: {},
+      siweAuthenticate: {
+        siwe: builtSiwe
+      }
+    }
+  });
+  return result.siweAuthenticate;
+}
+
+// src/core/actions/wrapper/sendTransaction.ts
+async function sendTransaction(client, { tx, metadata }) {
+  const result = await displayModal(client, {
+    metadata,
+    steps: {
+      login: {},
+      sendTransaction: { tx }
+    }
+  });
+  return result.sendTransaction;
+}
+
+export {
+  watchWalletStatus,
+  sendInteraction,
+  displayModal,
+  openSso,
+  siweAuthenticate,
+  sendTransaction
+};

package/dist/chunk-7MVQQ2X6.js

@@ -0,0 +1,381 @@
+import {
+  __publicField
+} from "./chunk-PKBMQBKP.js";
+
+// 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/Deferred.ts
+var Deferred = class {
+  constructor() {
+    __publicField(this, "_promise");
+    __publicField(this, "_resolve");
+    __publicField(this, "_reject");
+    __publicField(this, "resolve", (value) => {
+      this._resolve?.(value);
+    });
+    __publicField(this, "reject", (reason) => {
+      this._reject?.(reason);
+    });
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+};
+
+// src/core/utils/compression/compress.ts
+import { compressToBase64 } from "async-lz-string";
+import { sha256 } from "js-sha256";
+async function hashAndCompressData(data) {
+  const validationHash = sha256(JSON.stringify(data));
+  const hashProtectedData = {
+    ...data,
+    validationHash
+  };
+  const compressed = await compressJson(hashProtectedData);
+  const compressedHash = sha256(compressed);
+  return {
+    compressed,
+    compressedHash
+  };
+}
+async function compressJson(data) {
+  return compressToBase64(JSON.stringify(data));
+}
+
+// src/core/utils/compression/decompress.ts
+import { decompressFromBase64 } from "async-lz-string";
+import { sha256 as sha2562 } from "js-sha256";
+async function decompressDataAndCheckHash(compressedData) {
+  if (!(compressedData?.compressed && compressedData?.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 (!parsedData?.validationHash) {
+    throw new FrakRpcError(
+      RpcErrorCodes.corruptedResponse,
+      "Missing validation hash"
+    );
+  }
+  const expectedCompressedHash = sha2562(compressedData.compressed);
+  if (expectedCompressedHash !== compressedData.compressedHash) {
+    throw new FrakRpcError(
+      RpcErrorCodes.corruptedResponse,
+      "Invalid compressed hash"
+    );
+  }
+  const { validationHash: _, ...rawResultData } = parsedData;
+  const expectedValidationHash = sha2562(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 decompressFromBase64(data);
+  try {
+    return JSON.parse(decompressed);
+  } catch (e) {
+    console.error("Invalid compressed data", e);
+    return null;
+  }
+}
+
+// src/core/clients/transports/iframeChannelManager.ts
+function createIFrameChannelManager() {
+  const channels = /* @__PURE__ */ new Map();
+  return {
+    // TODO: Better id system?? uid stuff?
+    createChannel: (resolver) => {
+      const id = Math.random().toString(36).substring(7);
+      channels.set(id, resolver);
+      return id;
+    },
+    getRpcResolver: (id) => channels.get(id),
+    removeChannel: (id) => channels.delete(id),
+    destroy: () => channels.clear()
+  };
+}
+
+// src/core/utils/iframeHelper.ts
+var baseIframeProps = {
+  id: "nexus-wallet",
+  name: "nexus-wallet",
+  allow: "publickey-credentials-get *; clipboard-write; web-share *",
+  style: {
+    width: "0",
+    height: "0",
+    border: "0",
+    position: "absolute",
+    zIndex: 1e3,
+    top: "-1000px",
+    left: "-1000px"
+  }
+};
+function createIframe({
+  walletBaseUrl
+}) {
+  const alreadyCreatedIFrame = document.querySelector("#nexus-wallet");
+  if (alreadyCreatedIFrame) {
+    return Promise.resolve(void 0);
+  }
+  const iframe = document.createElement("iframe");
+  iframe.id = baseIframeProps.id;
+  iframe.name = baseIframeProps.name;
+  iframe.allow = baseIframeProps.allow;
+  iframe.style.zIndex = baseIframeProps.style.zIndex.toString();
+  changeIframeVisibility({ iframe, isVisible: false });
+  document.body.appendChild(iframe);
+  return new Promise((resolve) => {
+    iframe?.addEventListener("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%";
+  iframe.style.pointerEvents = "auto";
+}
+
+// src/core/clients/transports/iframeMessageHandler.ts
+function createIFrameMessageHandler({
+  nexusWalletUrl,
+  metadata,
+  iframe,
+  channelManager
+}) {
+  if (typeof window === "undefined") {
+    throw new FrakRpcError(
+      RpcErrorCodes.configError,
+      "iframe client should be used in the browser"
+    );
+  }
+  if (!iframe.contentWindow) {
+    throw new FrakRpcError(
+      RpcErrorCodes.configError,
+      "The iframe does not have a content window"
+    );
+  }
+  const contentWindow = iframe.contentWindow;
+  const isConnectedDeferred = new Deferred();
+  const msgHandler = async (event) => {
+    if (!event.origin) {
+      return;
+    }
+    if (new URL(event.origin).origin.toLowerCase() !== new URL(nexusWalletUrl).origin.toLowerCase()) {
+      return;
+    }
+    if ("lifecycle" in event.data) {
+      switch (event.data.lifecycle) {
+        case "connected":
+          isConnectedDeferred.resolve(true);
+          break;
+        case "show":
+        case "hide":
+          changeIframeVisibility({
+            iframe,
+            isVisible: event.data.lifecycle === "show"
+          });
+          break;
+      }
+      return;
+    }
+    const channel = event.data.id;
+    const resolver = channelManager.getRpcResolver(channel);
+    if (!resolver) {
+      return;
+    }
+    await resolver(event.data);
+  };
+  window.addEventListener("message", msgHandler);
+  const sendEvent = (message) => {
+    contentWindow.postMessage(message, {
+      targetOrigin: nexusWalletUrl
+    });
+  };
+  const cleanup = () => {
+    window.removeEventListener("message", msgHandler);
+  };
+  const isConnected = injectCssOnConnect({
+    isConnected: isConnectedDeferred.promise,
+    metadata,
+    sendEvent
+  });
+  return {
+    isConnected,
+    sendEvent,
+    cleanup
+  };
+}
+function injectCssOnConnect({
+  isConnected,
+  metadata,
+  sendEvent
+}) {
+  const css = metadata?.css;
+  if (!css) {
+    return isConnected;
+  }
+  return isConnected.then((connected) => {
+    sendEvent({
+      lifecycle: "modal-css",
+      data: css
+    });
+    return connected;
+  });
+}
+
+// src/core/clients/createIFrameNexusClient.ts
+function createIFrameNexusClient({
+  config,
+  iframe
+}) {
+  const channelManager = createIFrameChannelManager();
+  const messageHandler = createIFrameMessageHandler({
+    nexusWalletUrl: config.walletUrl,
+    metadata: config.metadata,
+    iframe,
+    channelManager
+  });
+  const request = async (args) => {
+    const isConnected = await messageHandler.isConnected;
+    if (!isConnected) {
+      throw new FrakRpcError(
+        RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
+    }
+    const result = new Deferred();
+    const channelId = channelManager.createChannel(async (message) => {
+      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);
+    messageHandler.sendEvent({
+      id: channelId,
+      // @ts-ignore, todo: idk why the fck it's needed
+      topic: args.method,
+      data: compressedMessage
+    });
+    return result.promise;
+  };
+  const listenerRequest = async (args, callback) => {
+    const isConnected = await messageHandler.isConnected;
+    if (!isConnected) {
+      throw new FrakRpcError(
+        RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
+    }
+    const channelId = channelManager.createChannel(async (message) => {
+      const decompressed = await decompressDataAndCheckHash(message.data);
+      if (decompressed.result) {
+        callback(decompressed.result);
+      } else {
+      }
+    });
+    const compressedMessage = await hashAndCompressData(args);
+    messageHandler.sendEvent({
+      id: channelId,
+      topic: args.method,
+      data: compressedMessage
+    });
+  };
+  const destroy = async () => {
+    channelManager.destroy();
+    messageHandler.cleanup();
+    iframe.remove();
+  };
+  return {
+    config,
+    waitForConnection: messageHandler.isConnected,
+    request,
+    listenerRequest,
+    destroy
+  };
+}
+
+export {
+  FrakRpcError,
+  ClientNotFound,
+  RpcErrorCodes,
+  Deferred,
+  hashAndCompressData,
+  compressJson,
+  decompressDataAndCheckHash,
+  decompressJson,
+  baseIframeProps,
+  createIframe,
+  createIFrameNexusClient
+};

package/dist/{chunk-72IEHEQX.js → chunk-GUDT2W6I.js}

@@ -3,8 +3,7 @@ import { concatHex, pad } from "viem";
 var PressTypeSelector = "0x02";
 var PressActionsSelector = {
   OpenArticle: "0xc0a24ffb",
-  ReadArticle: "0xd5bd0fbe",
-  Referred: "0x3d1508ad"
+  ReadArticle: "0xd5bd0fbe"
 };
 function openArticle({ articleId }) {
   const interactionData = concatHex([
@@ -26,23 +25,46 @@ function readArticle({ articleId }) {
     interactionData
   };
 }
+var PressInteractionEncoder = {
+  openArticle,
+  readArticle
+};
+
+// src/core/interactions/referralEncoder.ts
+import { concatHex as concatHex2, pad as pad2 } from "viem";
+var ReferralTypeSelector = "0x1E";
+var ReferralActionsSelector = {
+  CreateLink: "0xb2c0f17c",
+  Referred: "0x010cc3b9"
+};
+function createLink() {
+  const interactionData = concatHex2([
+    ReferralActionsSelector.CreateLink,
+    "0x"
+  ]);
+  return {
+    handlerTypeDenominator: ReferralTypeSelector,
+    interactionData
+  };
+}
 function referred({ referrer }) {
-  const interactionData = concatHex([
-    PressActionsSelector.Referred,
-    pad(referrer, { size: 32 })
+  const interactionData = concatHex2([
+    ReferralActionsSelector.Referred,
+    pad2(referrer, { size: 32 })
   ]);
   return {
-    handlerTypeDenominator: PressTypeSelector,
+    handlerTypeDenominator: ReferralTypeSelector,
     interactionData
   };
 }
-var PressInteractionEncoder = {
-  openArticle,
-  readArticle,
+var ReferralInteractionEncoder = {
+  createLink,
   referred
 };
 
 export {
   PressActionsSelector,
-  PressInteractionEncoder
+  PressInteractionEncoder,
+  ReferralActionsSelector,
+  ReferralInteractionEncoder
 };

package/dist/{chunk-NIFJZD3M.cjs → chunk-IQQTTKJL.cjs}

@@ -3,8 +3,7 @@ var _viem = require('viem');
 var PressTypeSelector = "0x02";
 var PressActionsSelector = {
   OpenArticle: "0xc0a24ffb",
-  ReadArticle: "0xd5bd0fbe",
-  Referred: "0x3d1508ad"
+  ReadArticle: "0xd5bd0fbe"
 };
 function openArticle({ articleId }) {
   const interactionData = _viem.concatHex.call(void 0, [
@@ -26,23 +25,46 @@ function readArticle({ articleId }) {
     interactionData
   };
 }
+var PressInteractionEncoder = {
+  openArticle,
+  readArticle
+};
+
+// src/core/interactions/referralEncoder.ts
+
+var ReferralTypeSelector = "0x1E";
+var ReferralActionsSelector = {
+  CreateLink: "0xb2c0f17c",
+  Referred: "0x010cc3b9"
+};
+function createLink() {
+  const interactionData = _viem.concatHex.call(void 0, [
+    ReferralActionsSelector.CreateLink,
+    "0x"
+  ]);
+  return {
+    handlerTypeDenominator: ReferralTypeSelector,
+    interactionData
+  };
+}
 function referred({ referrer }) {
   const interactionData = _viem.concatHex.call(void 0, [
-    PressActionsSelector.Referred,
+    ReferralActionsSelector.Referred,
     _viem.pad.call(void 0, referrer, { size: 32 })
   ]);
   return {
-    handlerTypeDenominator: PressTypeSelector,
+    handlerTypeDenominator: ReferralTypeSelector,
     interactionData
   };
 }
-var PressInteractionEncoder = {
-  openArticle,
-  readArticle,
+var ReferralInteractionEncoder = {
+  createLink,
   referred
 };
 
 
 
 
-exports.PressActionsSelector = PressActionsSelector; exports.PressInteractionEncoder = PressInteractionEncoder;
+
+
+exports.PressActionsSelector = PressActionsSelector; exports.PressInteractionEncoder = PressInteractionEncoder; exports.ReferralActionsSelector = ReferralActionsSelector; exports.ReferralInteractionEncoder = ReferralInteractionEncoder;

package/dist/chunk-S5FVCA2E.cjs

@@ -0,0 +1,86 @@
+"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; }// src/core/actions/watchWalletStatus.ts
+function watchWalletStatus(client, callback) {
+  return client.listenerRequest(
+    {
+      method: "frak_listenToWalletStatus"
+    },
+    callback
+  );
+}
+
+// src/core/utils/computeContentId.ts
+var _viem = require('viem');
+function computeContentId({ domain }) {
+  return _viem.keccak256.call(void 0, _viem.toHex.call(void 0, domain));
+}
+
+// src/core/actions/sendInteraction.ts
+async function sendInteraction(client, { contentId, interaction, validation }) {
+  const cId = _nullishCoalesce(contentId, () => ( computeContentId(client.config)));
+  return await client.request({
+    method: "frak_sendInteraction",
+    params: [cId, interaction, validation]
+  });
+}
+
+// src/core/actions/displayModal.ts
+async function displayModal(client, { steps, metadata }) {
+  return await client.request({
+    method: "frak_displayModal",
+    params: [steps, client.config.metadata.name, metadata]
+  });
+}
+
+// src/core/actions/openSso.ts
+async function openSso(client, args) {
+  const { metadata } = client.config;
+  await client.request({
+    method: "frak_sso",
+    params: [args, metadata.name, metadata.css]
+  });
+}
+
+// src/core/actions/wrapper/siweAuthenticate.ts
+var _siwe = require('viem/siwe');
+async function siweAuthenticate(client, { siwe, metadata }) {
+  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
+  };
+  const result = await displayModal(client, {
+    metadata,
+    steps: {
+      login: {},
+      siweAuthenticate: {
+        siwe: builtSiwe
+      }
+    }
+  });
+  return result.siweAuthenticate;
+}
+
+// src/core/actions/wrapper/sendTransaction.ts
+async function sendTransaction(client, { tx, metadata }) {
+  const result = await displayModal(client, {
+    metadata,
+    steps: {
+      login: {},
+      sendTransaction: { tx }
+    }
+  });
+  return result.sendTransaction;
+}
+
+
+
+
+
+
+
+
+exports.watchWalletStatus = watchWalletStatus; exports.sendInteraction = sendInteraction; exports.displayModal = displayModal; exports.openSso = openSso; exports.siweAuthenticate = siweAuthenticate; exports.sendTransaction = sendTransaction;