@frak-labs/core-sdk 0.0.2

package/dist/index.cjs

@@ -0,0 +1,326 @@
+"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 _chunkNJJQPEELcjs = require('./chunk-NJJQPEEL.cjs');
+
+
+
+
+var _chunkPR3T7O5Icjs = require('./chunk-PR3T7O5I.cjs');
+
+// src/utils/constants.ts
+var BACKUP_KEY = "nexus-wallet-backup";
+
+// src/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/clients/transports/iframeLifecycleManager.ts
+function createIFrameLifecycleManager({
+  iframe
+}) {
+  const isConnectedDeferred = new (0, _chunkNJJQPEELcjs.Deferred)();
+  const handler = async (messageEvent) => {
+    switch (messageEvent.iframeLifecycle) {
+      // Resolve the isConnected promise
+      case "connected":
+        isConnectedDeferred.resolve(true);
+        break;
+      // Perform a nexus backup
+      case "do-backup":
+        if (messageEvent.data.backup) {
+          localStorage.setItem(BACKUP_KEY, messageEvent.data.backup);
+        } else {
+          localStorage.removeItem(BACKUP_KEY);
+        }
+        break;
+      // Remove nexus backup
+      case "remove-backup":
+        localStorage.removeItem(BACKUP_KEY);
+        break;
+      // Change iframe visibility
+      case "show":
+      case "hide":
+        _chunkNJJQPEELcjs.changeIframeVisibility.call(void 0, {
+          iframe,
+          isVisible: messageEvent.iframeLifecycle === "show"
+        });
+        break;
+    }
+  };
+  return {
+    handleEvent: handler,
+    isConnected: isConnectedDeferred.promise
+  };
+}
+
+// src/clients/transports/iframeMessageHandler.ts
+function createIFrameMessageHandler({
+  frakWalletUrl,
+  iframe,
+  channelManager,
+  iframeLifecycleManager
+}) {
+  if (typeof window === "undefined") {
+    throw new (0, _chunkNJJQPEELcjs.FrakRpcError)(
+      _chunkNJJQPEELcjs.RpcErrorCodes.configError,
+      "iframe client should be used in the browser"
+    );
+  }
+  if (!iframe.contentWindow) {
+    throw new (0, _chunkNJJQPEELcjs.FrakRpcError)(
+      _chunkNJJQPEELcjs.RpcErrorCodes.configError,
+      "The iframe does not have a product window"
+    );
+  }
+  const contentWindow = iframe.contentWindow;
+  const msgHandler = async (event) => {
+    if (!(event.origin && URL.canParse(event.origin))) {
+      return;
+    }
+    if (new URL(event.origin).origin.toLowerCase() !== new URL(frakWalletUrl).origin.toLowerCase()) {
+      return;
+    }
+    if (typeof event.data !== "object") {
+      return;
+    }
+    if ("iframeLifecycle" in event.data) {
+      await iframeLifecycleManager.handleEvent(event.data);
+      return;
+    }
+    if ("clientLifecycle" in event.data) {
+      console.error(
+        "Client lifecycle event received on the client side, dismissing it"
+      );
+      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: frakWalletUrl
+    });
+  };
+  const cleanup = () => {
+    window.removeEventListener("message", msgHandler);
+  };
+  return {
+    sendEvent,
+    cleanup
+  };
+}
+
+// src/clients/createIFrameFrakClient.ts
+function createIFrameFrakClient({
+  config,
+  iframe
+}) {
+  const channelManager = createIFrameChannelManager();
+  const lifecycleManager = createIFrameLifecycleManager({ iframe });
+  const messageHandler = createIFrameMessageHandler({
+    frakWalletUrl: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.walletUrl]), () => ( "https://wallet.frak.id")),
+    iframe,
+    channelManager,
+    iframeLifecycleManager: lifecycleManager
+  });
+  const request = async (args) => {
+    const isConnected = await lifecycleManager.isConnected;
+    if (!isConnected) {
+      throw new (0, _chunkNJJQPEELcjs.FrakRpcError)(
+        _chunkNJJQPEELcjs.RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
+    }
+    const result = new (0, _chunkNJJQPEELcjs.Deferred)();
+    const channelId = channelManager.createChannel(async (message) => {
+      const decompressed = await _chunkNJJQPEELcjs.decompressDataAndCheckHash.call(void 0, message.data);
+      if (decompressed.error) {
+        result.reject(
+          new (0, _chunkNJJQPEELcjs.FrakRpcError)(
+            decompressed.error.code,
+            decompressed.error.message,
+            _optionalChain([decompressed, 'access', _2 => _2.error, 'optionalAccess', _3 => _3.data])
+          )
+        );
+      } else {
+        result.resolve(decompressed.result);
+      }
+      channelManager.removeChannel(channelId);
+    });
+    const compressedMessage = await _chunkNJJQPEELcjs.hashAndCompressData.call(void 0, args);
+    messageHandler.sendEvent({
+      id: channelId,
+      topic: args.method,
+      data: compressedMessage
+    });
+    return result.promise;
+  };
+  const listenerRequest = async (args, callback) => {
+    const isConnected = await lifecycleManager.isConnected;
+    if (!isConnected) {
+      throw new (0, _chunkNJJQPEELcjs.FrakRpcError)(
+        _chunkNJJQPEELcjs.RpcErrorCodes.clientNotConnected,
+        "The iframe provider isn't connected yet"
+      );
+    }
+    const channelId = channelManager.createChannel(async (message) => {
+      const decompressed = await _chunkNJJQPEELcjs.decompressDataAndCheckHash.call(void 0, message.data);
+      if (decompressed.result) {
+        callback(decompressed.result);
+      } else {
+        throw new (0, _chunkNJJQPEELcjs.InternalError)("No valid result in the response");
+      }
+    });
+    const compressedMessage = await _chunkNJJQPEELcjs.hashAndCompressData.call(void 0, args);
+    messageHandler.sendEvent({
+      id: channelId,
+      topic: args.method,
+      data: compressedMessage
+    });
+  };
+  const stopHeartbeat = setupHeartbeat(messageHandler, lifecycleManager);
+  const destroy = async () => {
+    stopHeartbeat();
+    channelManager.destroy();
+    messageHandler.cleanup();
+    iframe.remove();
+  };
+  const waitForSetup = postConnectionSetup({
+    config,
+    messageHandler,
+    lifecycleManager
+  });
+  return {
+    config,
+    waitForConnection: lifecycleManager.isConnected,
+    waitForSetup,
+    request,
+    listenerRequest,
+    destroy
+  };
+}
+function setupHeartbeat(messageHandler, lifecycleManager) {
+  const HEARTBEAT_INTERVAL = 100;
+  const HEARTBEAT_TIMEOUT = 3e4;
+  let heartbeatInterval;
+  let timeoutId;
+  const sendHeartbeat = () => messageHandler.sendEvent({
+    iframeLifecycle: "heartbeat"
+  });
+  async function startHeartbeat() {
+    sendHeartbeat();
+    heartbeatInterval = setInterval(sendHeartbeat, HEARTBEAT_INTERVAL);
+    timeoutId = setTimeout(() => {
+      stopHeartbeat();
+      console.log("Heartbeat timeout: connection failed");
+    }, HEARTBEAT_TIMEOUT);
+    await lifecycleManager.isConnected;
+    stopHeartbeat();
+  }
+  function stopHeartbeat() {
+    if (heartbeatInterval) {
+      clearInterval(heartbeatInterval);
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  }
+  startHeartbeat();
+  return stopHeartbeat;
+}
+async function postConnectionSetup({
+  config,
+  messageHandler,
+  lifecycleManager
+}) {
+  await lifecycleManager.isConnected;
+  const pushCss = async () => {
+    const cssLink = config.metadata.css;
+    if (!cssLink) return;
+    messageHandler.sendEvent({
+      clientLifecycle: "modal-css",
+      data: { cssLink }
+    });
+  };
+  const pushBackup = async () => {
+    if (typeof window === "undefined") return;
+    const backup = window.localStorage.getItem(BACKUP_KEY);
+    if (!backup) return;
+    messageHandler.sendEvent({
+      clientLifecycle: "restore-backup",
+      data: { backup }
+    });
+  };
+  await Promise.all([pushCss(), pushBackup()]);
+}
+
+// src/clients/setupClient.ts
+async function setupClient({
+  config
+}) {
+  const iframe = await _chunkNJJQPEELcjs.createIframe.call(void 0, {
+    config
+  });
+  if (!iframe) {
+    console.error("Failed to create iframe");
+    return;
+  }
+  const client = createIFrameFrakClient({
+    config,
+    iframe
+  });
+  await client.waitForSetup;
+  const waitForConnection = await client.waitForConnection;
+  if (!waitForConnection) {
+    console.error("Failed to connect to client");
+    return;
+  }
+  return client;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ClientNotFound = _chunkNJJQPEELcjs.ClientNotFound; exports.Deferred = _chunkNJJQPEELcjs.Deferred; exports.FrakContextManager = _chunkNJJQPEELcjs.FrakContextManager; exports.FrakRpcError = _chunkNJJQPEELcjs.FrakRpcError; exports.RpcErrorCodes = _chunkNJJQPEELcjs.RpcErrorCodes; exports.baseIframeProps = _chunkNJJQPEELcjs.baseIframeProps; exports.compressJson = _chunkNJJQPEELcjs.compressJson; exports.createIFrameFrakClient = createIFrameFrakClient; exports.createIframe = _chunkNJJQPEELcjs.createIframe; exports.decompressDataAndCheckHash = _chunkNJJQPEELcjs.decompressDataAndCheckHash; exports.decompressJson = _chunkNJJQPEELcjs.decompressJson; exports.hashAndCompressData = _chunkNJJQPEELcjs.hashAndCompressData; exports.interactionTypes = _chunkPR3T7O5Icjs.interactionTypes; exports.productTypes = _chunkPR3T7O5Icjs.productTypes; exports.productTypesMask = _chunkPR3T7O5Icjs.productTypesMask; exports.setupClient = setupClient;

package/dist/index.d.cts

@@ -0,0 +1,269 @@
+import { F as FrakWalletSdkConfig, a as FrakClient, b as FrakContext } from './context-GkNATUkF.cjs';
+export { C as ClientLifecycleEvent, D as DisplayModalParamsType, E as ExtractedParametersFromRpc, w as ExtractedReturnTypeFromRpc, r as FinalActionType, q as FinalModalStepType, G as GetProductInformationReturnType, u as IFrameEvent, v as IFrameLifecycleEvent, t as IFrameRpcEvent, I as IFrameRpcSchema, s as IFrameTransport, L as LoginModalStepType, d as ModalRpcMetadata, e as ModalRpcStepsInput, f as ModalRpcStepsResultType, g as ModalStepMetadata, M as ModalStepTypes, o as OpenInteractionSessionModalStepType, n as OpenInteractionSessionReturnType, O as OpenSsoParamsType, P as ProductTypesKey, R as RpcResponse, l as SendTransactionModalStepType, m as SendTransactionReturnType, k as SendTransactionTxType, h as SiweAuthenticateModalStepType, j as SiweAuthenticateReturnType, i as SiweAuthenticationParams, S as SsoMetadata, W as WalletStatusReturnType, p as productTypes, c as productTypesMask } from './context-GkNATUkF.cjs';
+export { P as PreparedInteraction, S as SendInteractionParamsType, a as SendInteractionReturnType } from './interaction-CTQ5-kqe.cjs';
+import 'viem';
+import 'viem/chains';
+import 'viem/siwe';
+
+/**
+ * Generic Frak RPC error
+ * @ignore
+ */
+declare class FrakRpcError<T = undefined> extends Error {
+    code: number;
+    data?: T | undefined;
+    constructor(code: number, message: string, data?: T | undefined);
+}
+/** @ignore */
+declare class ClientNotFound extends FrakRpcError {
+    constructor();
+}
+/**
+ * The different Frak RPC error codes
+ */
+declare const RpcErrorCodes: {
+    readonly parseError: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internalError: -32603;
+    readonly serverError: -32000;
+    readonly clientNotConnected: -32001;
+    readonly configError: -32002;
+    readonly corruptedResponse: -32003;
+    readonly clientAborted: -32004;
+    readonly walletNotConnected: -32005;
+    readonly serverErrorForInteractionDelegation: -32006;
+};
+
+/**
+ * The received encoded data from a client
+ *  -> The encoded should contain a HashProtectedData once decoded
+ *  @ignore
+ */
+type CompressedData = Readonly<{
+    compressed: string;
+    compressedHash: string;
+}>;
+/**
+ * The encoded data to send to a client / received by a client
+ *  @ignore
+ */
+type HashProtectedData<DataType> = Readonly<DataType & {
+    validationHash: string;
+}>;
+/**
+ * Represent a key provider used for the hashed and secure compression
+ *  @ignore
+ */
+type KeyProvider<DataType> = (value: DataType) => string[];
+
+/**
+ * Create a new iframe Frak client
+ * @param args
+ * @param args.config - The configuration to use for the Frak Wallet SDK
+ * @param args.iframe - The iframe to use for the communication
+ * @returns The created Frak Client
+ *
+ * @example
+ * const frakConfig: FrakWalletSdkConfig = {
+ *     metadata: {
+ *         name: "My app title",
+ *     },
+ * }
+ * const iframe = await createIframe({ config: frakConfig });
+ * const client = createIFrameFrakClient({ config: frakConfig, iframe });
+ */
+declare function createIFrameFrakClient({ config, iframe, }: {
+    config: FrakWalletSdkConfig;
+    iframe: HTMLIFrameElement;
+}): FrakClient;
+
+/**
+ * Directly setup the Frak client with an iframe
+ * Return when the FrakClient is ready (setup and communication estbalished with the wallet)
+ *
+ * @param config - The configuration to use for the Frak Wallet SDK
+ * @returns a Promise with the Frak Client
+ *
+ * @example
+ * const frakConfig: FrakWalletSdkConfig = {
+ *     metadata: {
+ *         name: "My app title",
+ *     },
+ * }
+ * const client = await setupClient({ config: frakConfig });
+ */
+declare function setupClient({ config, }: {
+    config: FrakWalletSdkConfig;
+}): Promise<FrakClient | undefined>;
+
+/**
+ * Base props for the iframe
+ * @ignore
+ */
+declare const baseIframeProps: {
+    id: string;
+    name: string;
+    allow: string;
+    style: {
+        width: string;
+        height: string;
+        border: string;
+        position: string;
+        zIndex: number;
+        top: string;
+        left: string;
+    };
+};
+/**
+ * Create the Frak iframe
+ * @param args
+ * @param args.walletBaseUrl - Use `config.walletUrl` instead. Will be removed in future versions.
+ * @param args.config - The configuration object containing iframe options, including the replacement for `walletBaseUrl`.
+ */
+declare function createIframe({ walletBaseUrl, config, }: {
+    walletBaseUrl?: string;
+    config?: FrakWalletSdkConfig;
+}): Promise<HTMLIFrameElement | undefined>;
+
+/**
+ * Compress the given params, and add hash protection to (rapidly) prevent interception modification
+ * @param data The params to encode
+ * @ignore
+ */
+declare function hashAndCompressData<T>(data: T): Promise<CompressedData>;
+/**
+ * Compress json data
+ * @param data
+ * @ignore
+ */
+declare function compressJson(data: unknown): Promise<string>;
+
+/**
+ * Decompress the given string
+ * @param compressedData The params to encode
+ * @ignore
+ */
+declare function decompressDataAndCheckHash<T>(compressedData: CompressedData): Promise<HashProtectedData<T>>;
+/**
+ * Decompress json data
+ * @param data
+ * @ignore
+ */
+declare function decompressJson<T>(data: string): Promise<T | null>;
+
+/**
+ * Compress the current Frak context
+ * @param context - The context to be compressed
+ * @returns A compressed string containing the Frak context
+ */
+declare function compress(context?: Partial<FrakContext>): string | undefined;
+/**
+ * Decompress the given Frak context
+ * @param context - The raw context to be decompressed into a `FrakContext`
+ * @returns The decompressed Frak context, or undefined if it fails
+ */
+declare function decompress(context?: string): FrakContext | undefined;
+/**
+ * Parse the current URL into a Frak Context
+ * @param args
+ * @param args.url - The url to parse
+ * @returns The parsed Frak context
+ */
+declare function parse({ url }: {
+    url: string;
+}): FrakContext | null | undefined;
+/**
+ * Populate the current url with the given Frak context
+ * @param args
+ * @param args.url - The url to update
+ * @param args.context - The context to update
+ * @returns The new url with the Frak context
+ */
+declare function update({ url, context, }: {
+    url?: string;
+    context: Partial<FrakContext>;
+}): string | null;
+/**
+ * Remove Frak context from current url
+ * @param url - The url to update
+ * @returns The new url without the Frak context
+ */
+declare function remove(url: string): string;
+/**
+ * Replace the current url with the given Frak context
+ * @param args
+ * @param args.url - The url to update
+ * @param args.context - The context to update
+ */
+declare function replaceUrl({ url: baseUrl, context, }: {
+    url?: string;
+    context: Partial<FrakContext> | null;
+}): void;
+/**
+ * Export our frak context "class"
+ */
+declare const FrakContextManager: {
+    compress: typeof compress;
+    decompress: typeof decompress;
+    parse: typeof parse;
+    update: typeof update;
+    remove: typeof remove;
+    replaceUrl: typeof replaceUrl;
+};
+
+/**
+ * Simple deferred promise wrapper
+ * @ignore
+ */
+declare class Deferred<T> {
+    private readonly _promise;
+    private _resolve;
+    private _reject;
+    constructor();
+    get promise(): Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+}
+
+/**
+ * The final keys for each interaction types (e.g. `openArticle`) -> interaction type
+ * @inline
+ */
+type InteractionTypesKey = {
+    [K in keyof typeof interactionTypes]: keyof (typeof interactionTypes)[K];
+}[keyof typeof interactionTypes];
+/**
+ * The keys for each interaction types (e.g. `press.openArticle`) -> category_type.interaction_type
+ * @inline
+ */
+type FullInteractionTypesKey = {
+    [Category in keyof typeof interactionTypes]: `${Category & string}.${keyof (typeof interactionTypes)[Category] & string}`;
+}[keyof typeof interactionTypes];
+/**
+ * Each interactions types according to the product types
+ */
+declare const interactionTypes: {
+    readonly press: {
+        readonly openArticle: "0xc0a24ffb";
+        readonly readArticle: "0xd5bd0fbe";
+    };
+    readonly dapp: {
+        readonly proofVerifiableStorageUpdate: "0x2ab2aeef";
+        readonly callableVerifiableStorageUpdate: "0xa07da986";
+    };
+    readonly webshop: {
+        readonly open: "0xb311798f";
+    };
+    readonly referral: {
+        readonly referred: "0x010cc3b9";
+        readonly createLink: "0xb2c0f17c";
+    };
+    readonly purchase: {
+        readonly started: "0xd87e90c3";
+        readonly completed: "0x8403aeb4";
+    };
+};
+
+export { ClientNotFound, type CompressedData, Deferred, FrakClient, FrakContext, FrakContextManager, FrakRpcError, FrakWalletSdkConfig, type FullInteractionTypesKey, type HashProtectedData, type InteractionTypesKey, type KeyProvider, RpcErrorCodes, baseIframeProps, compressJson, createIFrameFrakClient, createIframe, decompressDataAndCheckHash, decompressJson, hashAndCompressData, interactionTypes, setupClient };