@frak-labs/core-sdk 0.0.2

package/dist/actions/index.js

@@ -0,0 +1,352 @@
+import {
+  Deferred,
+  FrakContextManager,
+  FrakRpcError,
+  RpcErrorCodes
+} from "../chunk-K5SAPMC2.js";
+import {
+  ReferralInteractionEncoder
+} from "../chunk-VAINYZSV.js";
+import "../chunk-QZL2KCSB.js";
+
+// src/actions/watchWalletStatus.ts
+function watchWalletStatus(client, callback) {
+  if (!callback) {
+    return client.request({ method: "frak_listenToWalletStatus" }).then((result) => {
+      savePotentialToken(result.interactionToken);
+      return result;
+    });
+  }
+  const firstResult = new Deferred();
+  let hasResolved = false;
+  return client.listenerRequest(
+    {
+      method: "frak_listenToWalletStatus"
+    },
+    (status) => {
+      callback(status);
+      savePotentialToken(status.interactionToken);
+      if (!hasResolved) {
+        firstResult.resolve(status);
+        hasResolved = true;
+      }
+    }
+  ).then(() => firstResult.promise);
+}
+function savePotentialToken(interactionToken) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (interactionToken) {
+    window.sessionStorage.setItem(
+      "frak-wallet-interaction-token",
+      interactionToken
+    );
+  } else {
+    window.sessionStorage.removeItem("frak.interaction-token");
+  }
+}
+
+// src/utils/computeProductId.ts
+import { keccak256, toHex } from "viem";
+function computeProductId({ domain }) {
+  const effectiveDomain = domain ?? window.location.host;
+  return keccak256(toHex(effectiveDomain));
+}
+
+// src/actions/sendInteraction.ts
+async function sendInteraction(client, { productId, interaction, validation }) {
+  const pId = productId ?? computeProductId(client.config);
+  return await client.request({
+    method: "frak_sendInteraction",
+    params: [pId, interaction, validation]
+  });
+}
+
+// src/actions/displayModal.ts
+async function displayModal(client, { steps, metadata }) {
+  return await client.request({
+    method: "frak_displayModal",
+    params: [steps, client.config.metadata.name, metadata]
+  });
+}
+
+// src/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/actions/getProductInformation.ts
+async function getProductInformation(client) {
+  return await client.request({
+    method: "frak_getProductInformation"
+  });
+}
+
+// src/actions/trackPurchaseStatus.ts
+async function trackPurchaseStatus(args) {
+  if (typeof window === "undefined") {
+    console.warn("[Frak] No window found, can't track purchase");
+    return;
+  }
+  const interactionToken = window.sessionStorage.getItem(
+    "frak-wallet-interaction-token"
+  );
+  if (!interactionToken) {
+    console.warn("[Frak] No frak session found, skipping purchase check");
+    return;
+  }
+  await fetch("https://backend.frak.id/interactions/listenForPurchase", {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+      "x-wallet-sdk-auth": interactionToken
+    },
+    body: JSON.stringify(args)
+  });
+}
+
+// src/actions/wrapper/siweAuthenticate.ts
+import { generateSiweNonce } from "viem/siwe";
+async function siweAuthenticate(client, { siwe, metadata }) {
+  const effectiveDomain = client.config?.domain ?? window.location.host;
+  const realStatement = siwe?.statement ?? `I confirm that I want to use my Frak wallet on: ${client.config.metadata.name}`;
+  const builtSiwe = {
+    ...siwe,
+    statement: realStatement,
+    nonce: siwe?.nonce ?? generateSiweNonce(),
+    uri: siwe?.uri ?? `https://${effectiveDomain}`,
+    version: siwe?.version ?? "1",
+    domain: effectiveDomain
+  };
+  const result = await displayModal(client, {
+    metadata,
+    steps: {
+      login: {},
+      siweAuthenticate: {
+        siwe: builtSiwe
+      }
+    }
+  });
+  return result.siweAuthenticate;
+}
+
+// src/actions/wrapper/sendTransaction.ts
+async function sendTransaction(client, { tx, metadata }) {
+  const result = await displayModal(client, {
+    metadata,
+    steps: {
+      login: {},
+      sendTransaction: { tx }
+    }
+  });
+  return result.sendTransaction;
+}
+
+// src/actions/wrapper/modalBuilder.ts
+function modalBuilder(client, {
+  metadata,
+  login,
+  openSession
+}) {
+  const baseParams = {
+    steps: {
+      login: login ?? {},
+      openSession: openSession ?? {}
+    },
+    metadata
+  };
+  return modalStepsBuilder(client, baseParams);
+}
+function modalStepsBuilder(client, params) {
+  function sendTx(options) {
+    return modalStepsBuilder(client, {
+      ...params,
+      steps: {
+        ...params.steps,
+        sendTransaction: options
+      }
+    });
+  }
+  function reward(options) {
+    return modalStepsBuilder(
+      client,
+      {
+        ...params,
+        steps: {
+          ...params.steps,
+          final: {
+            ...options,
+            action: { key: "reward" }
+          }
+        }
+      }
+    );
+  }
+  function sharing(sharingOptions, options) {
+    return modalStepsBuilder(
+      client,
+      {
+        ...params,
+        steps: {
+          ...params.steps,
+          final: {
+            ...options,
+            action: { key: "sharing", options: sharingOptions }
+          }
+        }
+      }
+    );
+  }
+  async function display() {
+    return await displayModal(client, params);
+  }
+  return {
+    // Access current modal params
+    params,
+    // Function to add new steps
+    sendTx,
+    reward,
+    sharing,
+    // Display the modal
+    display
+  };
+}
+
+// src/actions/referral/processReferral.ts
+import { isAddressEqual } from "viem";
+async function processReferral(client, {
+  walletStatus,
+  frakContext,
+  modalConfig,
+  productId,
+  options
+}) {
+  let walletRequest = false;
+  async function getFreshWalletStatus() {
+    if (walletRequest) {
+      return;
+    }
+    walletRequest = true;
+    return ensureWalletConnected(client, {
+      modalConfig,
+      walletStatus
+    });
+  }
+  async function pushReferralInteraction(referrer) {
+    const interaction = ReferralInteractionEncoder.referred({
+      referrer
+    });
+    await sendInteraction(client, { productId, interaction });
+  }
+  try {
+    const { status, currentWallet } = await processReferralLogic({
+      initialWalletStatus: walletStatus,
+      getFreshWalletStatus,
+      pushReferralInteraction,
+      frakContext
+    });
+    FrakContextManager.replaceUrl({
+      url: window.location?.href,
+      context: options?.alwaysAppendUrl ? { r: currentWallet } : null
+    });
+    return status;
+  } catch (error) {
+    console.log("Error processing referral", { error });
+    FrakContextManager.replaceUrl({
+      url: window.location?.href,
+      context: options?.alwaysAppendUrl ? { r: walletStatus?.wallet } : null
+    });
+    return mapErrorToState(error);
+  }
+}
+async function processReferralLogic({
+  initialWalletStatus,
+  getFreshWalletStatus,
+  pushReferralInteraction,
+  frakContext
+}) {
+  let currentWallet = initialWalletStatus?.wallet;
+  if (!frakContext?.r) {
+    return { status: "no-referrer", currentWallet };
+  }
+  if (!currentWallet) {
+    currentWallet = await getFreshWalletStatus();
+  }
+  if (currentWallet && isAddressEqual(frakContext.r, currentWallet)) {
+    return { status: "self-referral", currentWallet };
+  }
+  if (!initialWalletStatus?.interactionSession) {
+    currentWallet = await getFreshWalletStatus();
+  }
+  await pushReferralInteraction(frakContext.r);
+  return { status: "success", currentWallet };
+}
+async function ensureWalletConnected(client, {
+  modalConfig,
+  walletStatus
+}) {
+  if (!walletStatus?.interactionSession) {
+    if (!modalConfig) {
+      return void 0;
+    }
+    const result = await displayModal(client, modalConfig);
+    return result?.login?.wallet ?? void 0;
+  }
+  return walletStatus.wallet ?? void 0;
+}
+function mapErrorToState(error) {
+  if (error instanceof FrakRpcError) {
+    switch (error.code) {
+      case RpcErrorCodes.walletNotConnected:
+        return "no-wallet";
+      case RpcErrorCodes.serverErrorForInteractionDelegation:
+        return "no-session";
+      default:
+        return "error";
+    }
+  }
+  return "error";
+}
+
+// src/actions/referral/referralInteraction.ts
+async function referralInteraction(client, {
+  productId,
+  modalConfig,
+  options
+} = {}) {
+  const frakContext = FrakContextManager.parse({
+    url: window.location.href
+  });
+  const currentWalletStatus = await watchWalletStatus(client);
+  try {
+    return await processReferral(client, {
+      walletStatus: currentWalletStatus,
+      frakContext,
+      modalConfig,
+      productId,
+      options
+    });
+  } catch (error) {
+    console.warn("Error processing referral", { error });
+  }
+  return;
+}
+export {
+  displayModal,
+  getProductInformation,
+  modalBuilder,
+  openSso,
+  processReferral,
+  referralInteraction,
+  sendInteraction,
+  sendTransaction,
+  siweAuthenticate,
+  trackPurchaseStatus,
+  watchWalletStatus
+};