@frak-labs/nexus-sdk 0.0.9 → 0.0.11

package/dist/chunk-V3S6RBRJ.cjs

@@ -0,0 +1,381 @@
+"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 _chunkETV4XYOVcjs = require('./chunk-ETV4XYOV.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 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() {
+    _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', _2 => _2._resolve, 'optionalCall', _3 => _3(value)]);
+    });
+    _chunkETV4XYOVcjs.__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/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) => {
+    _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/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 = _optionalChain([metadata, 'optionalAccess', _11 => _11.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,
+            _optionalChain([decompressed, 'access', _12 => _12.error, 'optionalAccess', _13 => _13.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
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FrakRpcError = FrakRpcError; 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.createIFrameNexusClient = createIFrameNexusClient;

package/dist/client-C7u9zGwC.d.cts

@@ -0,0 +1,332 @@
+import { Address, Hex, RpcSchema } from 'viem';
+import { Prettify } from 'viem/chains';
+import { SiweMessage } from 'viem/siwe';
+import { P as PreparedInteraction, a as SendInteractionReturnType } from './interaction-D3-M3nBh.cjs';
+
+/**
+ * Configuration for the Nexus Wallet SDK
+ */
+type NexusWalletSdkConfig = Readonly<{
+    walletUrl: string;
+    metadata: {
+        name: string;
+        css?: string;
+    };
+    domain: string;
+}>;
+
+/**
+ * SSO Metadata
+ */
+type SsoMetadata = {
+    logoUrl: string;
+    homepageLink: string;
+    links?: {
+        confidentialityLink?: string;
+        helpLink?: string;
+        cguLink?: string;
+    };
+};
+/**
+ * Params to start a SSO
+ */
+type OpenSsoParamsType = {
+    redirectUrl?: string;
+    directExit?: boolean;
+    metadata: SsoMetadata;
+};
+
+/**
+ * Represent a generic modal step type
+ */
+type GenericModalStepType<TKey, TParams, TReturns> = {
+    key: TKey;
+    params: TParams extends never ? ModalStepMetadata : ModalStepMetadata & TParams;
+    returns: TReturns;
+};
+type ModalStepMetadata = {
+    metadata?: {
+        title?: string;
+        description?: string;
+        primaryActionText?: string;
+        secondaryActionText?: string;
+    };
+};
+
+type LoginWithSso = {
+    allowSso: true;
+    ssoMetadata: SsoMetadata;
+};
+type LoginWithoutSso = {
+    allowSso?: false;
+    ssoMetadata?: never;
+};
+/**
+ * Generic type of modal we will display to the end user
+ */
+type LoginModalStepType = GenericModalStepType<"login", {
+    articleUrl?: string;
+} & (LoginWithSso | LoginWithoutSso), {
+    wallet: Address;
+}>;
+
+/**
+ * Parameters of the send transaction rpc request
+ */
+type SiweAuthenticationParams = Omit<SiweMessage, "address" | "chainId">;
+/**
+ * Return type of the send transaction rpc request
+ */
+type SiweAuthenticateReturnType = Readonly<{
+    signature: Hex;
+    message: string;
+}>;
+/**
+ * Generic type of modal we will display to the end user
+ */
+type SiweAuthenticateModalStepType = GenericModalStepType<"siweAuthenticate", {
+    siwe: SiweAuthenticationParams;
+}, SiweAuthenticateReturnType>;
+
+/**
+ * Generic format representing a tx to be sent
+ *  todo: exploit the EIP-5792 here? https://eips.ethereum.org/EIPS/eip-5792
+ */
+type SendTransactionTxType = Readonly<{
+    to: Address;
+    data?: Hex;
+    value?: Hex;
+}>;
+/**
+ * Return type of the send transaction rpc request
+ */
+type SendTransactionReturnType = Readonly<{
+    hash: Hex;
+}>;
+type SendTransactionModalStepType = GenericModalStepType<"sendTransaction", {
+    tx: SendTransactionTxType | SendTransactionTxType[];
+}, SendTransactionReturnType>;
+
+/**
+ * Return type of the send transaction rpc request
+ */
+type OpenInteractionSessionReturnType = Readonly<{
+    startTimestamp: number;
+    endTimestamp: number;
+}>;
+/**
+ * Generic type of modal we will display to the end user
+ */
+type OpenInteractionSessionModalStepType = GenericModalStepType<"openSession", object, OpenInteractionSessionReturnType>;
+
+/**
+ * Generic type of modal we will display to the end user
+ */
+type SuccessModalStepType = GenericModalStepType<"success", {
+    sharing?: {
+        popupTitle?: string;
+        text?: string;
+        link?: string;
+    };
+}, object>;
+
+/**
+ * Generic type of steps we will display in the modal to the end user
+ */
+type ModalStepTypes = LoginModalStepType | SiweAuthenticateModalStepType | SendTransactionModalStepType | OpenInteractionSessionModalStepType | SuccessModalStepType;
+/**
+ * Type for the result of a modal request
+ */
+type ModalRpcStepsResultType<T extends ModalStepTypes[] = ModalStepTypes[]> = {
+    [K in T[number]["key"]]: Extract<T[number], {
+        key: K;
+    }>["returns"];
+};
+/**
+ * Type for the RPC input of a modal
+ */
+type ModalRpcStepsInput<T extends ModalStepTypes[] = ModalStepTypes[]> = {
+    [K in T[number]["key"]]?: Extract<T[number], {
+        key: K;
+    }>["params"];
+};
+/**
+ * RPC metadata for the modal
+ */
+type ModalRpcMetadata = Readonly<{
+    header?: {
+        title?: string;
+        icon?: string;
+    };
+    context?: string;
+}>;
+/**
+ * Generic params used to display modals
+ */
+type DisplayModalParamsType<T extends ModalStepTypes[]> = {
+    steps: ModalRpcStepsInput<T>;
+    metadata?: ModalRpcMetadata;
+};
+
+type WalletStatusReturnType = Readonly<WalletConnected | WalletNotConnected>;
+type WalletConnected = {
+    key: "connected";
+    wallet: Address;
+    interactionSession?: {
+        startTimestamp: number;
+        endTimestamp: number;
+    };
+};
+type WalletNotConnected = {
+    key: "not-connected";
+};
+
+/**
+ * RPC interface that's used for the iframe communication
+ */
+type IFrameRpcSchema = [
+    /**
+     * Method used to listen to the wallet status
+     */
+    {
+        Method: "frak_listenToWalletStatus";
+        Parameters?: undefined;
+        ReturnType: WalletStatusReturnType;
+    },
+    /**
+     * Method to transmit a user interaction
+     */
+    {
+        Method: "frak_displayModal";
+        Parameters: [
+            requests: ModalRpcStepsInput,
+            name: string,
+            metadata?: ModalRpcMetadata
+        ];
+        ReturnType: ModalRpcStepsResultType;
+    },
+    /**
+     * Method to transmit a user interaction
+     */
+    {
+        Method: "frak_sendInteraction";
+        Parameters: [
+            contentId: Hex,
+            interaction: PreparedInteraction,
+            signature?: Hex
+        ];
+        ReturnType: SendInteractionReturnType;
+    },
+    /**
+     * Method to start a SSO
+     */
+    {
+        Method: "frak_sso";
+        Parameters: [
+            params: OpenSsoParamsType,
+            name: string,
+            customCss?: string
+        ];
+        ReturnType: undefined;
+    }
+];
+
+/**
+ * Type that extract the possible parameters from a RPC Schema
+ */
+type ExtractedParametersFromRpc<TRpcSchema extends RpcSchema> = {
+    [K in keyof TRpcSchema]: Prettify<{
+        method: TRpcSchema[K] extends TRpcSchema[number] ? TRpcSchema[K]["Method"] : string;
+    } & (TRpcSchema[K] extends TRpcSchema[number] ? TRpcSchema[K]["Parameters"] extends undefined ? {
+        params?: never;
+    } : {
+        params: TRpcSchema[K]["Parameters"];
+    } : never)>;
+}[number];
+/**
+ * Type that extract the possible return type from a RPC Schema
+ */
+type ExtractedReturnTypeFromRpc<TRpcSchema extends RpcSchema, TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>> = ExtractedMethodFromRpc<TRpcSchema, TParameters["method"]>["ReturnType"];
+/**
+ * Type that extract the possible return type from a RPC Schema
+ */
+type ExtractedMethodFromRpc<TRpcSchema extends RpcSchema, TMethod extends ExtractedParametersFromRpc<TRpcSchema>["method"] = ExtractedParametersFromRpc<TRpcSchema>["method"]> = Extract<TRpcSchema[number], {
+    Method: TMethod;
+}>;
+/**
+ * Raw response that we will receive after an rpc request
+ */
+type RpcResponse<TRpcSchema extends RpcSchema, TMethod extends TRpcSchema[number]["Method"] = TRpcSchema[number]["Method"]> = {
+    result: Extract<TRpcSchema[number], {
+        Method: TMethod;
+    }>["ReturnType"];
+    error?: never;
+} | {
+    result?: never;
+    error: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+};
+/**
+ * Type used for a one shot request function
+ */
+type RequestFn<TRpcSchema extends RpcSchema> = <TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>, _ReturnType = ExtractedReturnTypeFromRpc<TRpcSchema, TParameters>>(args: TParameters) => Promise<_ReturnType>;
+/**
+ * Type used for a one shot request function
+ */
+type ListenerRequestFn<TRpcSchema extends RpcSchema> = <TParameters extends ExtractedParametersFromRpc<TRpcSchema> = ExtractedParametersFromRpc<TRpcSchema>>(args: TParameters, callback: (result: ExtractedReturnTypeFromRpc<TRpcSchema, TParameters>) => void) => Promise<void>;
+/**
+ * IFrame transport interface
+ */
+type IFrameTransport = {
+    /**
+     * Wait for the connection to be established
+     */
+    waitForConnection: Promise<boolean>;
+    /**
+     * Function used to perform a single request via the iframe transport
+     */
+    request: RequestFn<IFrameRpcSchema>;
+    /**
+     * Function used to listen to a request response via the iframe transport
+     */
+    listenerRequest: ListenerRequestFn<IFrameRpcSchema>;
+    /**
+     * Function used to destroy the iframe transport
+     */
+    destroy: () => Promise<void>;
+};
+/**
+ * Represent an iframe event
+ */
+type IFrameEvent = IFrameRpcEvent | IFrameLifecycleEvent;
+/**
+ * Represent an iframe rpc event
+ */
+type IFrameRpcEvent = {
+    id: string;
+    topic: ExtractedParametersFromRpc<IFrameRpcSchema>["method"];
+    data: {
+        compressed: string;
+        compressedHash: string;
+    };
+};
+type IFrameLifecycleEvent = {
+    lifecycle: "connected" | "show" | "hide";
+    data: never;
+} | LifecycleEventCSS;
+type LifecycleEventCSS = {
+    lifecycle: "modal-css";
+    data: string;
+};
+
+/**
+ * Representing a Nexus client
+ */
+type NexusClient = {
+    config: NexusWalletSdkConfig;
+} & IFrameTransport;
+
+export type { DisplayModalParamsType as D, ExtractedParametersFromRpc as E, IFrameRpcSchema as I, LoginModalStepType as L, ModalRpcMetadata as M, NexusClient as N, OpenSsoParamsType as O, RpcResponse as R, SiweAuthenticationParams as S, WalletStatusReturnType as W, SiweAuthenticateReturnType as a, SendTransactionModalStepType as b, SendTransactionReturnType as c, ModalStepTypes as d, ModalRpcStepsResultType as e, NexusWalletSdkConfig as f, SuccessModalStepType as g, SsoMetadata as h, ModalRpcStepsInput as i, ModalStepMetadata as j, SiweAuthenticateModalStepType as k, SendTransactionTxType as l, OpenInteractionSessionReturnType as m, OpenInteractionSessionModalStepType as n, IFrameTransport as o, IFrameRpcEvent as p, IFrameEvent as q, ExtractedReturnTypeFromRpc as r };