@frak-labs/nexus-sdk 0.0.14 → 0.0.16

package/dist/chunk-FYMOOHMT.js

@@ -0,0 +1,254 @@
+import {
+  __publicField
+} from "./chunk-HY6YATLS.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 InternalError = class extends FrakRpcError {
+  constructor(message) {
+    super(RpcErrorCodes.internalError, message);
+  }
+};
+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,
+  serverErrorForInteractionDelegation: -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/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(alreadyCreatedIFrame);
+  }
+  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/utils/FrakContext.ts
+var contextKey = "fCtx";
+async function parse({ url }) {
+  if (!url) return null;
+  const urlObj = new URL(url);
+  const nexusContext = urlObj.searchParams.get(contextKey);
+  if (!nexusContext) return null;
+  const parsedContext = await decompressJson(nexusContext);
+  if (!parsedContext) return null;
+  return parsedContext;
+}
+async function update({
+  url,
+  context
+}) {
+  if (!url) return null;
+  const currentContext = await parse({ url });
+  const mergedContext = currentContext ? { ...currentContext, ...context } : context;
+  const compressedContext = await compressJson(mergedContext);
+  if (!compressedContext) return;
+  const urlObj = new URL(url);
+  urlObj.searchParams.set(contextKey, compressedContext);
+  return urlObj.toString();
+}
+function remove(url) {
+  const urlObj = new URL(url);
+  urlObj.searchParams.delete(contextKey);
+  return urlObj.toString();
+}
+async function replaceUrl({
+  url,
+  context
+}) {
+  if (!window.location?.href || typeof window === "undefined") {
+    console.error("No window found, can't update context");
+    return;
+  }
+  const newUrl = await update({
+    url,
+    context
+  });
+  if (!newUrl) return;
+  window.history.replaceState(null, "", newUrl.toString());
+}
+var FrakContextManager = {
+  parse,
+  update,
+  remove,
+  replaceUrl
+};
+
+export {
+  FrakRpcError,
+  InternalError,
+  ClientNotFound,
+  RpcErrorCodes,
+  Deferred,
+  hashAndCompressData,
+  compressJson,
+  decompressDataAndCheckHash,
+  decompressJson,
+  baseIframeProps,
+  createIframe,
+  changeIframeVisibility,
+  FrakContextManager
+};

package/dist/chunk-HY6YATLS.js

@@ -0,0 +1,53 @@
+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);
+
+// src/core/constants/productTypes.ts
+var productTypes = {
+  // content type
+  dapp: 1,
+  press: 2,
+  webshop: 3,
+  // feature type
+  referral: 30,
+  purchase: 31
+};
+var productTypesMask = Object.entries(
+  productTypes
+).reduce(
+  (acc, [key, value]) => {
+    acc[key] = BigInt(1) << BigInt(value);
+    return acc;
+  },
+  {}
+);
+
+// src/core/constants/interactionTypes.ts
+var interactionTypes = {
+  press: {
+    openArticle: "0xc0a24ffb",
+    readArticle: "0xd5bd0fbe"
+  },
+  dapp: {
+    proofVerifiableStorageUpdate: "0x2ab2aeef",
+    callableVerifiableStorageUpdate: "0xa07da986"
+  },
+  webshop: {
+    open: "0xb311798f"
+  },
+  referral: {
+    referred: "0x010cc3b9",
+    createLink: "0xb2c0f17c"
+  },
+  purchase: {
+    started: "0xd87e90c3",
+    completed: "0x8403aeb4"
+  }
+};
+
+export {
+  __publicField,
+  productTypes,
+  productTypesMask,
+  interactionTypes
+};

package/dist/chunk-J655X6YR.cjs

@@ -0,0 +1,254 @@
+"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; }
+
+var _chunkUFJ7W6CQcjs = require('./chunk-UFJ7W6CQ.cjs');
+
+// src/core/types/rpc/error.ts
+var FrakRpcError = class extends Error {
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+  }
+};
+var InternalError = class extends FrakRpcError {
+  constructor(message) {
+    super(RpcErrorCodes.internalError, message);
+  }
+};
+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,
+  serverErrorForInteractionDelegation: -32006
+};
+
+// src/core/utils/Deferred.ts
+var Deferred = class {
+  constructor() {
+    _chunkUFJ7W6CQcjs.__publicField.call(void 0, this, "_promise");
+    _chunkUFJ7W6CQcjs.__publicField.call(void 0, this, "_resolve");
+    _chunkUFJ7W6CQcjs.__publicField.call(void 0, this, "_reject");
+    _chunkUFJ7W6CQcjs.__publicField.call(void 0, this, "resolve", (value) => {
+      _optionalChain([this, 'access', _2 => _2._resolve, 'optionalCall', _3 => _3(value)]);
+    });
+    _chunkUFJ7W6CQcjs.__publicField.call(void 0, this, "reject", (reason) => {
+      _optionalChain([this, 'access', _4 => _4._reject, 'optionalCall', _5 => _5(reason)]);
+    });
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+    });
+  }
+  get promise() {
+    return this._promise;
+  }
+};
+
+// 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', _6 => _6.compressed]) && _optionalChain([compressedData, 'optionalAccess', _7 => _7.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', _8 => _8.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
+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(alreadyCreatedIFrame);
+  }
+  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) => {
+    _optionalChain([iframe, 'optionalAccess', _9 => _9.addEventListener, 'call', _10 => _10("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/utils/FrakContext.ts
+var contextKey = "fCtx";
+async function parse({ url }) {
+  if (!url) return null;
+  const urlObj = new URL(url);
+  const nexusContext = urlObj.searchParams.get(contextKey);
+  if (!nexusContext) return null;
+  const parsedContext = await decompressJson(nexusContext);
+  if (!parsedContext) return null;
+  return parsedContext;
+}
+async function update({
+  url,
+  context
+}) {
+  if (!url) return null;
+  const currentContext = await parse({ url });
+  const mergedContext = currentContext ? { ...currentContext, ...context } : context;
+  const compressedContext = await compressJson(mergedContext);
+  if (!compressedContext) return;
+  const urlObj = new URL(url);
+  urlObj.searchParams.set(contextKey, compressedContext);
+  return urlObj.toString();
+}
+function remove(url) {
+  const urlObj = new URL(url);
+  urlObj.searchParams.delete(contextKey);
+  return urlObj.toString();
+}
+async function replaceUrl({
+  url,
+  context
+}) {
+  if (!_optionalChain([window, 'access', _11 => _11.location, 'optionalAccess', _12 => _12.href]) || typeof window === "undefined") {
+    console.error("No window found, can't update context");
+    return;
+  }
+  const newUrl = await update({
+    url,
+    context
+  });
+  if (!newUrl) return;
+  window.history.replaceState(null, "", newUrl.toString());
+}
+var FrakContextManager = {
+  parse,
+  update,
+  remove,
+  replaceUrl
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FrakRpcError = FrakRpcError; exports.InternalError = InternalError; exports.ClientNotFound = ClientNotFound; exports.RpcErrorCodes = RpcErrorCodes; exports.Deferred = Deferred; exports.hashAndCompressData = hashAndCompressData; exports.compressJson = compressJson; exports.decompressDataAndCheckHash = decompressDataAndCheckHash; exports.decompressJson = decompressJson; exports.baseIframeProps = baseIframeProps; exports.createIframe = createIframe; exports.changeIframeVisibility = changeIframeVisibility; exports.FrakContextManager = FrakContextManager;

package/dist/chunk-TIKEZMSD.js

@@ -0,0 +1,114 @@
+import {
+  interactionTypes,
+  productTypes
+} from "./chunk-HY6YATLS.js";
+
+// src/core/interactions/pressEncoder.ts
+import { concatHex, pad, toHex } from "viem";
+function openArticle({ articleId }) {
+  const interactionData = concatHex([
+    interactionTypes.press.openArticle,
+    pad(articleId, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: toHex(productTypes.press),
+    interactionData
+  };
+}
+function readArticle({ articleId }) {
+  const interactionData = concatHex([
+    interactionTypes.press.readArticle,
+    pad(articleId, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: toHex(productTypes.press),
+    interactionData
+  };
+}
+var PressInteractionEncoder = {
+  openArticle,
+  readArticle
+};
+
+// src/core/interactions/referralEncoder.ts
+import { concatHex as concatHex2, pad as pad2, toHex as toHex2 } from "viem";
+function createLink() {
+  const interactionData = concatHex2([
+    interactionTypes.referral.createLink,
+    "0x"
+  ]);
+  return {
+    handlerTypeDenominator: toHex2(productTypes.referral),
+    interactionData
+  };
+}
+function referred({ referrer }) {
+  const interactionData = concatHex2([
+    interactionTypes.referral.referred,
+    pad2(referrer, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: toHex2(productTypes.referral),
+    interactionData
+  };
+}
+var ReferralInteractionEncoder = {
+  createLink,
+  referred
+};
+
+// src/core/interactions/purchaseEncoder.ts
+import { concatHex as concatHex3, encodeAbiParameters, pad as pad3, toHex as toHex3 } from "viem";
+function startPurchase({
+  purchaseId
+}) {
+  const interactionData = concatHex3([
+    interactionTypes.purchase.started,
+    pad3(purchaseId, { size: 32 })
+  ]);
+  return {
+    handlerTypeDenominator: toHex3(productTypes.purchase),
+    interactionData
+  };
+}
+function completedPurchase({
+  purchaseId,
+  proof
+}) {
+  const innerData = encodeAbiParameters(
+    [{ type: "uint256" }, { type: "bytes32[]" }],
+    [BigInt(purchaseId), proof]
+  );
+  const interactionData = concatHex3([
+    interactionTypes.purchase.completed,
+    innerData
+  ]);
+  return {
+    handlerTypeDenominator: toHex3(productTypes.purchase),
+    interactionData
+  };
+}
+var PurchaseInteractionEncoder = {
+  startPurchase,
+  completedPurchase
+};
+
+// src/core/interactions/webshopEncoder.ts
+import { concatHex as concatHex4, toHex as toHex4 } from "viem";
+function open() {
+  const interactionData = concatHex4([interactionTypes.webshop.open, "0x"]);
+  return {
+    handlerTypeDenominator: toHex4(productTypes.webshop),
+    interactionData
+  };
+}
+var WebShopInteractionEncoder = {
+  open
+};
+
+export {
+  PressInteractionEncoder,
+  ReferralInteractionEncoder,
+  PurchaseInteractionEncoder,
+  WebShopInteractionEncoder
+};