@gearbox-protocol/ui-kit 4.7.0 → 4.8.0-next.1

package/dist/esm/user-agreements/agreement-cache.js

@@ -0,0 +1,15 @@
+const n = ["gearbox-agreement"];
+function s(t, e, r) {
+  return [e, t.toLowerCase(), ...r].join("@");
+}
+function u(t, e, r) {
+  t.getQueryData(n)?.[e]?.status !== "ALLOWED" && t.setQueryData(n, (o) => ({
+    ...o,
+    [e]: r
+  }));
+}
+export {
+  n as AGREEMENT_QUERY_KEY,
+  s as getAgreementKey,
+  u as setAgreementStatus
+};

package/dist/esm/user-agreements/agreement-error.js

@@ -0,0 +1,44 @@
+class i extends Error {
+  constructor(r, t) {
+    super(`Request failed with status ${r}`), this.status = r, this.data = t, this.name = "AgreementHttpError";
+  }
+}
+class e extends Error {
+  constructor(r, t) {
+    super(r), this.code = r, this.originalError = t, this.name = "AgreementError";
+  }
+  static type = "AgreementError";
+  type = e.type;
+  static isAgreementError(r) {
+    return !!r && typeof r == "object" && "type" in r && r.type === e.type || r instanceof e;
+  }
+  static getErrorCode(r, t) {
+    if (!(r instanceof i)) return "unknownError";
+    switch (r.status) {
+      case 400:
+        return "badRequest";
+      case 500:
+        return "internalServerError";
+      case 404:
+        return "notFound";
+      case 401: {
+        const n = r.data ?? {}, o = Number(n.currentVersion), s = Number(n.signedVersion) || 0;
+        return o === t && s !== 0 && s < t ? "notLogged_passed_v2Sig" : "notLogged_passed";
+      }
+      case 451:
+        return "notLogged_notPassed";
+      default:
+        return "unknownError";
+    }
+  }
+  static fromError(r, t) {
+    return e.isAgreementError(r) ? r : new e(
+      e.getErrorCode(r, t),
+      r
+    );
+  }
+}
+export {
+  e as AgreementError,
+  i as AgreementHttpError
+};

package/dist/esm/user-agreements/agreement-service.js

@@ -0,0 +1,122 @@
+import { AgreementError as i, AgreementHttpError as o } from "./agreement-error.js";
+import { DEFAULT_LEGAL_MESSAGE as c, hashMessage as g } from "./legal-messages.js";
+const h = "https://auth.gearbox.foundation/agreements", u = "https://app.gearbox.finance/api/check-access", E = {
+  notLogged_passed: "NOT_SIGNED",
+  notLogged_passed_v2Sig: "NOT_SIGNED",
+  notLogged_notPassed: "BLOCKED",
+  badRequest: "NOT_SIGNED",
+  notFound: "ALLOWED",
+  internalServerError: "ALLOWED",
+  unknownError: "NOT_SIGNED"
+};
+async function d(n) {
+  const e = await n.text();
+  if (e)
+    try {
+      return JSON.parse(e);
+    } catch {
+      return e;
+    }
+}
+async function r(n, e) {
+  const t = await fetch(n, e), s = await d(t);
+  if (!t.ok) throw new o(t.status, s);
+  return s;
+}
+class p {
+  config;
+  legalMessage;
+  constructor(e) {
+    this.config = {
+      ...e,
+      signatureEndpoint: e.signatureEndpoint ?? h,
+      accessCheckEndpoint: e.accessCheckEndpoint ?? u
+    }, this.legalMessage = e.legalMessage || c;
+  }
+  async checkAgreement(e) {
+    try {
+      return { status: await this.checkSignatureOnServer(
+        e.account,
+        g(this.legalMessage.text),
+        e.chainId
+      ) };
+    } catch (t) {
+      throw i.fromError(t, this.legalMessage.version);
+    }
+  }
+  async signAgreement(e) {
+    try {
+      return await this.signMessage(e);
+    } catch (t) {
+      throw i.fromError(t, this.legalMessage.version);
+    }
+  }
+  /**
+   * Check access (e.g., geo-blocking). Any failure counts as not allowed.
+   */
+  async checkAccess() {
+    if (!this.config.accessCheckEndpoint) return !0;
+    try {
+      return (await r(this.config.accessCheckEndpoint))?.allowed === !0;
+    } catch {
+      return !1;
+    }
+  }
+  getLegalMessage() {
+    return this.legalMessage.text;
+  }
+  getLegalMessageVersion() {
+    return this.legalMessage.version;
+  }
+  async checkSignatureOnServer(e, t, s) {
+    const a = new URLSearchParams({
+      address: e,
+      agreementHash: t
+    });
+    return s !== void 0 && a.set("chainId", String(s)), await r(`${this.config.signatureEndpoint}?${a}`), "ALLOWED";
+  }
+  async signMessage({
+    signer: e,
+    account: t,
+    chainId: s
+  }) {
+    const a = await e.signMessage({
+      message: this.legalMessage.text,
+      account: t
+    });
+    return await this.submitSignature({
+      account: t,
+      signature: a,
+      chainId: s,
+      hash: g(this.legalMessage.text)
+    }), { status: "ALLOWED" };
+  }
+  async submitSignature({
+    account: e,
+    hash: t,
+    signature: s,
+    chainId: a
+  }) {
+    await r(this.config.signatureEndpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        address: e,
+        signature: s,
+        chainId: a,
+        agreementHash: t
+      })
+    });
+  }
+  static getAgreementStatus(e) {
+    return {
+      status: E[e],
+      hasV2Signature: e === "notLogged_passed_v2Sig"
+    };
+  }
+}
+export {
+  p as AgreementService,
+  u as GEARBOX_ACCESS_CHECK_ENDPOINT,
+  h as GEARBOX_USER_AGREEMENTS_ENDPOINT
+};

package/dist/esm/user-agreements/index.js

@@ -0,0 +1,25 @@
+import { AgreementError as A } from "./agreement-error.js";
+import { AgreementService as L, GEARBOX_ACCESS_CHECK_ENDPOINT as G, GEARBOX_USER_AGREEMENTS_ENDPOINT as e } from "./agreement-service.js";
+import { COMBINED_LEGAL_MESSAGES as r, CURRENT_COMBINED_LEGAL_MESSAGE_VERSION as M, CURRENT_LEGAL_MESSAGE_VERSION as N, CURRENT_RWA_LEGAL_MESSAGE_VERSION as o, DEFAULT_COMBINED_LEGAL_MESSAGE as O, DEFAULT_LEGAL_MESSAGE as C, DEFAULT_RWA_LEGAL_MESSAGE as I, LEGAL_MESSAGES as T, PERMISSIONLESS_LEGAL_MESSAGE as m, RWA_LEGAL_MESSAGES as t, SAFE_LEGAL_MESSAGE as D, hashMessage as U } from "./legal-messages.js";
+import { useAgreement as f } from "./use-agreement.js";
+import { useBlockedRegion as p } from "./use-blocked-region.js";
+export {
+  A as AgreementError,
+  L as AgreementService,
+  r as COMBINED_LEGAL_MESSAGES,
+  M as CURRENT_COMBINED_LEGAL_MESSAGE_VERSION,
+  N as CURRENT_LEGAL_MESSAGE_VERSION,
+  o as CURRENT_RWA_LEGAL_MESSAGE_VERSION,
+  O as DEFAULT_COMBINED_LEGAL_MESSAGE,
+  C as DEFAULT_LEGAL_MESSAGE,
+  I as DEFAULT_RWA_LEGAL_MESSAGE,
+  G as GEARBOX_ACCESS_CHECK_ENDPOINT,
+  e as GEARBOX_USER_AGREEMENTS_ENDPOINT,
+  T as LEGAL_MESSAGES,
+  m as PERMISSIONLESS_LEGAL_MESSAGE,
+  t as RWA_LEGAL_MESSAGES,
+  D as SAFE_LEGAL_MESSAGE,
+  U as hashMessage,
+  f as useAgreement,
+  p as useBlockedRegion
+};

package/dist/esm/user-agreements/legal-messages.js

@@ -0,0 +1,61 @@
+import { sha256 as r, stringToBytes as s } from "viem";
+function g(n) {
+  return r(s(n), "hex").slice(2);
+}
+const i = {
+  version: 2,
+  text: `By accessing or using Gearbox App, I agree to the Terms of Service (https://gearbox.fi/terms) and confirm that I have read and understood the Privacy Notice (https://gearbox.fi/privacy) and Risk Disclosure Statement (https://gearbox.fi/risks).
+I hereby further represent and warrant that:
+- I’m not a resident of or located in the United States of America (including its territories: American Samoa, Guam, Puerto Rico, the Northern Mariana Islands and the U.S. Virgin Islands) or any other Restricted Jurisdiction (as defined in the Terms of Service);
+- I’m not a Prohibited Person (as defined in the Terms of Service) nor acting on behalf of a Prohibited Person;
+- I understand that if I fail to maintain sufficient collateral when using the Gearbox Protocol, my credit account(s) may be liquidated, in which case a penalty may be charged by the protocol;
+- I acknowledge that Gearbox App and related software are experimental, and that the use of experimental software may result in complete loss of my funds.`
+}, o = {
+  version: 3,
+  text: `By signing this message, I hereby represent, warrant and confirm that:
+- I agree to the Terms of Service (https://gearbox.finance/terms) and acknowledge the Privacy Notice (https://gearbox.finance/privacy).
+- I represent and confirm that I am not a Prohibited Person (as defined in the above Terms of Service) and am not acting on behalf of one.
+- I acknowledge that the Gearbox App, related software, and smart contracts are experimental and may contain errors or vulnerabilities. I understand that their use may result in the complete loss of my funds. I have read the Risk Disclosure Statement (https://gearbox.finance/risks) and I voluntarily assume all risks described in it.
+`
+}, e = {
+  2: i,
+  3: o
+}, c = 3, E = e[c] ?? e[3], d = {
+  version: 1,
+  text: `By signing this message, I hereby represent, warrant and confirm that:
+- I agree to the Terms of Service (https://gearbox.finance/terms) and RWA Markets Interface Terms & Conditions (https://gearbox.finance/rwa-tc), and acknowledge the Privacy Notice (https://gearbox.finance/privacy)”.
+- I represent and confirm that I am not a Prohibited Person (as defined in the above Terms of Service) and am not acting on behalf of one.
+- I acknowledge that the Gearbox App, RWA Markets Interface, related software, and smart contracts are experimental and may contain errors or vulnerabilities. I understand that their use may result in the complete loss of my funds. I have read the Risk Disclosure Statement (https://gearbox.finance/risks) and I voluntarily assume all risks described in it and the above RWA Markets Interface Terms & Conditions.
+`
+}, t = {
+  1: d
+}, h = 1, S = t[h] ?? t[1], l = {
+  version: 1,
+  text: `By signing this message, I hereby represent, warrant, and confirm that:
+- I agree to the Terms of Service (https://gearbox.finance/terms) and RWA Markets Interface Terms & Conditions (https://www.gearbox.finance/rwa-tc), and acknowledge the Privacy Notice (https://gearbox.finance/privacy).
+- I represent and confirm that I am not a Prohibited Person (as defined in the above Terms of Service) and am not acting on behalf of one.
+- I acknowledge that the Gearbox App, RWA Markets Interface, related software, and smart contracts are experimental and may contain errors or vulnerabilities. I understand that their use may result in the complete loss of my funds. I have read the Risk Disclosure Statement (https://gearbox.finance/risks) and I voluntarily assume all risks described in it and the documents indicated above.
+`
+}, a = {
+  1: l
+}, m = 1, p = a[m] ?? a[1], I = {
+  version: 1,
+  text: "By signing this message, I agree to the Terms of Service (https://permissionless.gearbox.foundation/legal/terms-of-service) and acknowledge the Privacy Notice (https://permissionless.gearbox.foundation/legal/privacy-notice). I have read the Risk Disclosure Statement (https://permissionless.gearbox.foundation/legal/risk-disclosure) and I voluntarily assume all risks described in it."
+}, b = {
+  version: 1,
+  text: "By signing this message, I agree to the Terms of Service (https://safe.gearbox.finance/legal/terms-of-service) and acknowledge the Privacy Notice (https://safe.gearbox.finance/legal/privacy-notice). I have read the Risk Disclosure Statement (https://safe.gearbox.finance/legal/risk-disclosure) and I voluntarily assume all risks described in it."
+};
+export {
+  a as COMBINED_LEGAL_MESSAGES,
+  m as CURRENT_COMBINED_LEGAL_MESSAGE_VERSION,
+  c as CURRENT_LEGAL_MESSAGE_VERSION,
+  h as CURRENT_RWA_LEGAL_MESSAGE_VERSION,
+  p as DEFAULT_COMBINED_LEGAL_MESSAGE,
+  E as DEFAULT_LEGAL_MESSAGE,
+  S as DEFAULT_RWA_LEGAL_MESSAGE,
+  e as LEGAL_MESSAGES,
+  I as PERMISSIONLESS_LEGAL_MESSAGE,
+  t as RWA_LEGAL_MESSAGES,
+  b as SAFE_LEGAL_MESSAGE,
+  g as hashMessage
+};

package/dist/esm/user-agreements/types.js

@@ -0,0 +1 @@
+

package/dist/esm/user-agreements/use-agreement.js

@@ -0,0 +1,130 @@
+import { useQueryClient as q, useQuery as S, useMutation as O } from "@tanstack/react-query";
+import { useMemo as T } from "react";
+import { useAccount as R, useChainId as Y } from "wagmi";
+import { AGREEMENT_QUERY_KEY as A, getAgreementKey as s, setAgreementStatus as u } from "./agreement-cache.js";
+import { AgreementError as N } from "./agreement-error.js";
+import { AgreementService as y } from "./agreement-service.js";
+const U = [];
+function B(F) {
+  const {
+    config: I,
+    account: K,
+    chainId: M,
+    autoCheck: k = !0,
+    additionalQueryDep: o = U,
+    onCheckAgreement: _,
+    onCheckAgreementError: v,
+    onSignAgreement: C,
+    onSignAgreementSuccess: Q,
+    onSignAgreementError: w
+  } = F, { address: D } = R(), L = Y(), d = q(), r = K ?? D, f = M ?? L, i = T(
+    () => new y(I),
+    [I]
+  ), n = i.getLegalMessageVersion(), h = S({
+    queryKey: A,
+    staleTime: Number.POSITIVE_INFINITY,
+    refetchOnWindowFocus: !1,
+    retry: !1,
+    enabled: !1,
+    initialData: () => ({}),
+    queryFn: async () => ({})
+  }), g = T(
+    () => r ? h.data?.[s(r, n, o)] : void 0,
+    [
+      h.data,
+      r,
+      n,
+      o
+    ]
+  ), m = S({
+    queryKey: [...A, "check", r, ...o],
+    staleTime: Number.POSITIVE_INFINITY,
+    refetchOnWindowFocus: !1,
+    retry: !1,
+    enabled: k && !!r && g?.status === void 0,
+    queryFn: async (e) => {
+      if (!r) return null;
+      const t = s(
+        r,
+        n,
+        o
+      );
+      try {
+        const c = { account: r, chainId: f };
+        _?.(c);
+        const a = await i.checkAgreement(c);
+        return u(e.client, t, a), a;
+      } catch (c) {
+        const a = N.fromError(c, n);
+        v?.({ error: a, account: r, chainId: f });
+        const E = y.getAgreementStatus(a.code);
+        return u(e.client, t, E), E;
+      }
+    }
+  }), l = O({
+    mutationKey: [...A, "sign"],
+    onMutate: (e) => {
+      C?.({
+        account: e.account,
+        chainId: e.chainId,
+        legalMessageVersion: n
+      });
+      const t = s(
+        e.account,
+        n,
+        o
+      );
+      u(d, t, {
+        status: "AWAITING_SIGNATURE"
+      });
+    },
+    mutationFn: (e) => i.signAgreement(e),
+    onSuccess: (e, t) => {
+      const c = s(
+        t.account,
+        n,
+        o
+      );
+      u(d, c, e), Q?.({
+        account: t.account,
+        result: e,
+        chainId: t.chainId,
+        legalMessageVersion: n
+      });
+    },
+    onError: (e, t) => {
+      const c = s(
+        t.account,
+        n,
+        o
+      ), a = N.fromError(e, n);
+      w?.({
+        error: a,
+        account: t.account,
+        chainId: t.chainId
+      }), u(
+        d,
+        c,
+        y.getAgreementStatus(a.code)
+      );
+    }
+  }), P = async () => {
+    if (r)
+      return m.refetch().then((e) => e.data ?? void 0);
+  }, V = (e) => l.mutateAsync(e), b = (m.isLoading || m.isFetching) && g?.status === void 0;
+  return {
+    status: g?.status,
+    isLoading: b,
+    isSigning: l.isPending,
+    error: m.error || l.error || null,
+    checkAgreement: P,
+    signAgreement: V,
+    hasV2Signature: g?.hasV2Signature ?? !1,
+    legalMessage: i.getLegalMessage(),
+    legalMessageVersion: n,
+    allStatuses: h.data || {}
+  };
+}
+export {
+  B as useAgreement
+};

package/dist/esm/user-agreements/use-blocked-region.js

@@ -0,0 +1,24 @@
+import { useQuery as o } from "@tanstack/react-query";
+import { useMemo as n } from "react";
+import { AgreementService as t } from "./agreement-service.js";
+function d(e) {
+  const s = n(
+    () => new t(e),
+    [e]
+  ), r = o({
+    queryKey: ["blockedRegion", e.accessCheckEndpoint],
+    retry: !1,
+    staleTime: Number.POSITIVE_INFINITY,
+    refetchOnWindowFocus: !1,
+    enabled: !!e.accessCheckEndpoint,
+    queryFn: async () => !await s.checkAccess()
+  });
+  return {
+    isBlocked: r.data ?? !1,
+    isLoading: r.isLoading || r.isFetching,
+    isError: r.isError
+  };
+}
+export {
+  d as useBlockedRegion
+};

package/dist/esm/utils/index.js

@@ -1,34 +1,39 @@
 import { cn as o, cn as t } from "./cn.js";
-import { APPROXIMATE_SYMBOL as p, formatTimestamp as a, shortenHash as f } from "./format.js";
-import { formatLeverage as x, formatLeverageExact as i } from "./format-leverage.js";
-import { formatMoney as l, percentageTemplate as c } from "./format-money.js";
+import { APPROXIMATE_SYMBOL as m, formatTimestamp as p, shortenHash as f } from "./format.js";
+import { formatLeverage as i, formatLeverageExact as x } from "./format-leverage.js";
+import { formatMoney as S, percentageTemplate as c } from "./format-money.js";
 import { formatPnl as T } from "./format-pnl.js";
-import { formatOraclePrice as I } from "./format-price.js";
-import { slippageTemplate as d } from "./format-slippage.js";
-import { leveragePresets as u } from "./leverage-presets.js";
-import { bnToLiquidationPriceView as w, parseInputToBN as E } from "./parse-input-to-bn.js";
-import { shortenString as N } from "./shorten-string.js";
-import { tokenTemplateString as S } from "./templates.js";
-import { openInNewWindow as B } from "./window.js";
-import { Z_INDEX as _ } from "./z-index.js";
+import { formatOraclePrice as A } from "./format-price.js";
+import { slippageTemplate as P } from "./format-slippage.js";
+import { leveragePresets as I } from "./leverage-presets.js";
+import { bnToLiquidationPriceView as M, parseInputToBN as N } from "./parse-input-to-bn.js";
+import { shortenString as _ } from "./shorten-string.js";
+import { tokenTemplateString as h } from "./templates.js";
+import { DEFAULT_SAFE_DOMAINS as v, isBinanceSDK as w, isSafeAppsSDK as B, isSafeDomain as F } from "./wallet.js";
+import { openInNewWindow as X } from "./window.js";
+import { Z_INDEX as k } from "./z-index.js";
 export {
-  p as APPROXIMATE_SYMBOL,
-  _ as Z_INDEX,
-  w as bnToLiquidationPriceView,
+  m as APPROXIMATE_SYMBOL,
+  v as DEFAULT_SAFE_DOMAINS,
+  k as Z_INDEX,
+  M as bnToLiquidationPriceView,
   o as cn,
   t as default,
-  x as formatLeverage,
-  i as formatLeverageExact,
-  l as formatMoney,
-  I as formatOraclePrice,
+  i as formatLeverage,
+  x as formatLeverageExact,
+  S as formatMoney,
+  A as formatOraclePrice,
   T as formatPnl,
-  a as formatTimestamp,
-  u as leveragePresets,
-  B as openInNewWindow,
-  E as parseInputToBN,
+  p as formatTimestamp,
+  w as isBinanceSDK,
+  B as isSafeAppsSDK,
+  F as isSafeDomain,
+  I as leveragePresets,
+  X as openInNewWindow,
+  N as parseInputToBN,
   c as percentageTemplate,
   f as shortenHash,
-  N as shortenString,
-  d as slippageTemplate,
-  S as tokenTemplateString
+  _ as shortenString,
+  P as slippageTemplate,
+  h as tokenTemplateString
 };

package/dist/esm/utils/wallet.js

@@ -0,0 +1,37 @@
+const i = [
+  /blockscout\.com(\/|$)/,
+  /app\.safe\.global(\/|$)/,
+  /coinshift\.global(\/|$)/,
+  /explorer\.optimism\.io(\/|$)/
+];
+function a(e) {
+  return e.type === "safe" || e.id === "safe" || e.name.toLowerCase().includes("safe");
+}
+function s(e) {
+  return e.type === "binance" || e.id.toLowerCase().includes("binance") || e.name.toLowerCase().includes("binance");
+}
+function r() {
+  try {
+    return window.self !== window.top;
+  } catch {
+    return !0;
+  }
+}
+function o() {
+  try {
+    return new URL(document.referrer).host;
+  } catch {
+    return document.referrer;
+  }
+}
+function u(e = i) {
+  if (typeof window > "u" || !r()) return !1;
+  const n = o();
+  return e.some((t) => t.test(n));
+}
+export {
+  i as DEFAULT_SAFE_DOMAINS,
+  s as isBinanceSDK,
+  a as isSafeAppsSDK,
+  u as isSafeDomain
+};

package/dist/types/user-agreements/agreement-cache.d.ts

@@ -0,0 +1,11 @@
+import { QueryClient } from '@tanstack/react-query';
+import { Address } from 'viem';
+import { AgreementResult } from './types';
+export type AgreementRecord = Record<string, AgreementResult>;
+export declare const AGREEMENT_QUERY_KEY: readonly ["gearbox-agreement"];
+export declare function getAgreementKey(account: Address, version: number, additionalQueryDep: string[]): string;
+/**
+ * An ALLOWED status is final: later checks or failed signatures never
+ * downgrade it
+ */
+export declare function setAgreementStatus(client: QueryClient, authKey: string, result: AgreementResult): void;

package/dist/types/user-agreements/agreement-error.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Non-2xx response from an agreements endpoint
+ */
+export declare class AgreementHttpError extends Error {
+    status: number;
+    data: unknown;
+    constructor(status: number, data: unknown);
+}
+export type AgreementErrorCode = "notLogged_passed" | "notLogged_passed_v2Sig" | "notLogged_notPassed" | "badRequest" | "notFound" | "internalServerError" | "unknownError";
+export declare class AgreementError extends Error {
+    code: AgreementErrorCode;
+    originalError?: unknown | undefined;
+    static type: "AgreementError";
+    type: "AgreementError";
+    constructor(code: AgreementErrorCode, originalError?: unknown | undefined);
+    static isAgreementError(e: unknown): e is AgreementError;
+    static getErrorCode(e: unknown, legalMessageVersion: number): AgreementErrorCode;
+    static fromError(e: unknown, legalMessageVersion: number): AgreementError;
+}

package/dist/types/user-agreements/agreement-service.d.ts

@@ -0,0 +1,25 @@
+import { AgreementErrorCode } from './agreement-error';
+import { AgreementConfig, AgreementResult, CheckAgreementProps, SignAgreementProps } from './types';
+export declare const GEARBOX_USER_AGREEMENTS_ENDPOINT = "https://auth.gearbox.foundation/agreements";
+export declare const GEARBOX_ACCESS_CHECK_ENDPOINT = "https://app.gearbox.finance/api/check-access";
+/**
+ * Service for legal agreement signing.
+ * Contract wallets (Safe) are verified on-chain by the server.
+ */
+export declare class AgreementService {
+    private config;
+    private legalMessage;
+    constructor(config: AgreementConfig);
+    checkAgreement(props: CheckAgreementProps): Promise<AgreementResult>;
+    signAgreement(props: SignAgreementProps): Promise<AgreementResult>;
+    /**
+     * Check access (e.g., geo-blocking). Any failure counts as not allowed.
+     */
+    checkAccess(): Promise<boolean>;
+    getLegalMessage(): string;
+    getLegalMessageVersion(): number;
+    private checkSignatureOnServer;
+    private signMessage;
+    private submitSignature;
+    static getAgreementStatus(t: AgreementErrorCode): AgreementResult;
+}

package/dist/types/user-agreements/index.d.ts

@@ -0,0 +1,6 @@
+export { AgreementError, type AgreementErrorCode } from './agreement-error';
+export * from './agreement-service';
+export * from './legal-messages';
+export * from './types';
+export * from './use-agreement';
+export * from './use-blocked-region';

package/dist/types/user-agreements/legal-messages.d.ts

@@ -0,0 +1,49 @@
+import { LegalMessage } from './types';
+/**
+ * Hash function to compute SHA256 of message text
+ */
+export declare function hashMessage(text: string): string;
+/**
+ * All legal message versions
+ */
+export declare const LEGAL_MESSAGES: Record<number, LegalMessage>;
+/**
+ * Current legal message version
+ */
+export declare const CURRENT_LEGAL_MESSAGE_VERSION: number;
+/**
+ * Default legal message (current version)
+ */
+export declare const DEFAULT_LEGAL_MESSAGE: LegalMessage;
+/**
+ * All rwa legal message versions
+ */
+export declare const RWA_LEGAL_MESSAGES: Record<number, LegalMessage>;
+/**
+ * Current rwa legal message version
+ */
+export declare const CURRENT_RWA_LEGAL_MESSAGE_VERSION: number;
+/**
+ * Default rwa legal message (current version)
+ */
+export declare const DEFAULT_RWA_LEGAL_MESSAGE: LegalMessage;
+/**
+ * All combined legal message versions
+ */
+export declare const COMBINED_LEGAL_MESSAGES: Record<number, LegalMessage>;
+/**
+ * Current combined legal message version
+ */
+export declare const CURRENT_COMBINED_LEGAL_MESSAGE_VERSION: number;
+/**
+ * Default combined legal message (current version)
+ */
+export declare const DEFAULT_COMBINED_LEGAL_MESSAGE: LegalMessage;
+/**
+ * Legal message for Permissionless Interface
+ */
+export declare const PERMISSIONLESS_LEGAL_MESSAGE: LegalMessage;
+/**
+ * Legal message for Gearbox Safe
+ */
+export declare const SAFE_LEGAL_MESSAGE: LegalMessage;

package/dist/types/user-agreements/types.d.ts

@@ -0,0 +1,28 @@
+import { Address, WalletClient } from 'viem';
+export type AgreementStatus = "ALLOWED" | "NOT_SIGNED" | "BLOCKED" | "AWAITING_SIGNATURE";
+export interface AgreementResult {
+    status: AgreementStatus;
+    hasV2Signature?: boolean;
+}
+export interface LegalMessage {
+    version: number;
+    text: string;
+}
+export interface CheckAgreementProps {
+    account: Address;
+    /** Hint for the server: chain to check for Safe on-chain approval first */
+    chainId?: number;
+}
+export interface SignAgreementProps {
+    account: Address;
+    signer: WalletClient;
+    chainId: number;
+}
+export interface AgreementConfig {
+    /** Endpoint for signature verification (default: GEARBOX_USER_AGREEMENTS_ENDPOINT) */
+    signatureEndpoint?: string;
+    /** Endpoint for geo-access check (default: GEARBOX_ACCESS_CHECK_ENDPOINT) */
+    accessCheckEndpoint?: string;
+    /** Legal message for signing */
+    legalMessage?: LegalMessage;
+}