@tbookdev/vault-react-sui 0.1.0

package/README.md

@@ -0,0 +1,85 @@
+# @tbookdev/vault-react-sui
+
+Headless React hooks and provider for TBook Sui vault integrations.
+
+This package assumes your app already provides:
+
+- `QueryClientProvider` from `@tanstack/react-query`
+- `SuiClientProvider` and `WalletProvider` from `@mysten/dapp-kit`
+
+## Install
+
+```bash
+pnpm add @tbookdev/vault-react-sui @tbookdev/vault-sdk-sui
+```
+
+## Provider
+
+```tsx
+import { TBookSuiVaultProvider } from "@tbookdev/vault-react-sui";
+
+export function AppProviders({ children }: { children: React.ReactNode }) {
+  return (
+    <TBookSuiVaultProvider network="testnet" vaultId="rcusdp-sui">
+      {children}
+    </TBookSuiVaultProvider>
+  );
+}
+```
+
+## Hooks
+
+```tsx
+import {
+  useSuiDeposit,
+  useSuiTransactionHistory,
+  useSuiUsdcBalance,
+  useSuiVaultBalances,
+  useSuiVaultInfo,
+} from "@tbookdev/vault-react-sui";
+
+function VaultPanel() {
+  const vaultInfo = useSuiVaultInfo();
+  const balances = useSuiVaultBalances();
+  const usdc = useSuiUsdcBalance();
+  const history = useSuiTransactionHistory();
+  const deposit = useSuiDeposit();
+
+  return (
+    <button onClick={() => deposit.mutate({ amount: 100_000_000n })}>
+      Deposit 100 USDC
+    </button>
+  );
+}
+```
+
+## Transaction Builders
+
+`local-sdk` builds Sui transaction bytes in the browser through
+`@tbookdev/vault-sdk-sui`. It is the default on every network.
+
+The API server base URL is selected from `network`, independent of
+`txBuilderMode`: `testnet` points at the deployed sandbox Gateway API, while
+`mainnet` stays empty until the production Gateway API is deployed.
+If `gateway-api` is selected on a network without a configured Gateway API,
+the write hook reports a configuration error only when it tries to build the
+transaction through the API.
+
+```tsx
+<TBookSuiVaultProvider network="testnet" txBuilderMode="local-sdk">
+  {children}
+</TBookSuiVaultProvider>
+```
+
+`gateway-api` calls the selected TBook Gateway API to build unsigned transaction
+bytes, then signs and executes them with the connected Sui wallet. Select it
+explicitly when you want API-built transactions.
+
+```tsx
+<TBookSuiVaultProvider
+  network="testnet"
+  txBuilderMode="gateway-api"
+>
+  {children}
+</TBookSuiVaultProvider>
+```

package/dist/index.cjs

@@ -0,0 +1,511 @@
+'use strict';
+
+var react = require('react');
+var vaultSdkSui = require('@tbookdev/vault-sdk-sui');
+var jsxRuntime = require('react/jsx-runtime');
+var dappKit = require('@mysten/dapp-kit');
+var reactQuery = require('@tanstack/react-query');
+
+// src/provider.tsx
+var DEFAULT_STALE_TIMES = {
+  vaultInfo: 3e4,
+  balances: 1e4,
+  history: 1e4,
+  usdcBalance: 1e4
+};
+var DEFAULT_REFETCH_INTERVALS = {
+  vaultInfo: 6e4,
+  balances: 3e4,
+  history: 3e4,
+  usdcBalance: 3e4
+};
+var DEFAULT_SUI_VAULT_ID = "rcusdp-sui";
+var SUI_TESTNET_GATEWAY_API_BASE_URL = "https://1cm2fjkq6k.execute-api.ap-southeast-1.amazonaws.com/v1";
+function defaultGatewayApiBaseUrl(network) {
+  return network === "testnet" ? SUI_TESTNET_GATEWAY_API_BASE_URL : void 0;
+}
+function stripTrailingSlash(url) {
+  return url.replace(/\/+$/, "");
+}
+function createSuiVaultConfig(input) {
+  const vaultId = input.vaultId ?? DEFAULT_SUI_VAULT_ID;
+  const txBuilderMode = input.txBuilderMode ?? "local-sdk";
+  const gatewayApiBaseUrl = input.gatewayApiBaseUrl ?? defaultGatewayApiBaseUrl(input.network);
+  if (txBuilderMode === "custom" && !input.customTxBuilder) {
+    throw new Error("customTxBuilder is required when txBuilderMode is custom");
+  }
+  return {
+    network: input.network,
+    vaultId,
+    vault: vaultSdkSui.getSuiVaultConfig(vaultId, input.network),
+    txBuilderMode,
+    gatewayApiBaseUrl: gatewayApiBaseUrl ? stripTrailingSlash(gatewayApiBaseUrl) : void 0,
+    publishableKey: input.publishableKey,
+    customTxBuilder: input.customTxBuilder,
+    staleTimes: { ...DEFAULT_STALE_TIMES, ...input.staleTimes },
+    refetchIntervals: { ...DEFAULT_REFETCH_INTERVALS, ...input.refetchIntervals },
+    preflightChecks: input.preflightChecks ?? true
+  };
+}
+var TBookSuiVaultContext = react.createContext(null);
+function TBookSuiVaultProvider({ children, ...input }) {
+  const value = react.useMemo(
+    () => createSuiVaultConfig(input),
+    [
+      input.network,
+      input.vaultId,
+      input.txBuilderMode,
+      input.gatewayApiBaseUrl,
+      input.publishableKey,
+      input.customTxBuilder,
+      input.preflightChecks,
+      input.staleTimes,
+      input.refetchIntervals
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TBookSuiVaultContext.Provider, { value, children });
+}
+function useTBookSuiVault() {
+  const ctx = react.useContext(TBookSuiVaultContext);
+  if (!ctx) {
+    throw new Error(
+      "useTBookSuiVault must be used within a <TBookSuiVaultProvider>."
+    );
+  }
+  return ctx;
+}
+function parseDecimalAmount(value, decimals = vaultSdkSui.USDC_DECIMALS) {
+  const input = String(value).trim();
+  if (!/^\d+(\.\d+)?$/.test(input)) {
+    throw new Error(`Invalid decimal amount: ${value}`);
+  }
+  const [whole, fraction = ""] = input.split(".");
+  if (fraction.length > decimals) {
+    throw new Error(`Amount has more than ${decimals} decimal places: ${value}`);
+  }
+  const scale = 10n ** BigInt(decimals);
+  return BigInt(whole) * scale + BigInt(fraction.padEnd(decimals, "0") || "0");
+}
+function formatRawAmount(value, decimals = vaultSdkSui.USDC_DECIMALS) {
+  const raw = BigInt(value);
+  const scale = 10n ** BigInt(decimals);
+  const whole = raw / scale;
+  const fraction = (raw % scale).toString().padStart(decimals, "0").replace(/0+$/, "");
+  return fraction ? `${whole}.${fraction}` : whole.toString();
+}
+function toRawAmount(value, decimals = vaultSdkSui.USDC_DECIMALS) {
+  return typeof value === "bigint" ? value : parseDecimalAmount(value, decimals);
+}
+
+// src/query-keys.ts
+var ROOT = "tbook-sui";
+var suiVaultQueryKeys = {
+  all: [ROOT],
+  vault: (network, vaultId) => [ROOT, "vault", network, vaultId],
+  vaultInfo: (network, vaultId) => [ROOT, "vault", network, vaultId, "info"],
+  balances: (network, vaultId, address) => [ROOT, "vault", network, vaultId, "balances", address],
+  history: (network, vaultId, address) => [ROOT, "vault", network, vaultId, "history", address],
+  usdcBalance: (network, address, coinType) => [ROOT, "wallet", network, address, "usdc", coinType]
+};
+
+// src/errors.ts
+var TBookSuiVaultReactError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TBookSuiVaultReactError";
+  }
+};
+function walletNotConnected() {
+  return new TBookSuiVaultReactError("WALLET_NOT_CONNECTED", "Wallet not connected");
+}
+
+// src/gateway-api.ts
+var TBookSuiGatewayApiClient = class {
+  baseUrl;
+  apiKey;
+  fetcher;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.apiKey = options.apiKey;
+    this.fetcher = options.fetcher ?? ((input, init) => globalThis.fetch(input, init));
+  }
+  buildDepositTx(vaultId, body) {
+    return this.post(`/vaults/${vaultId}/tx/deposit`, body);
+  }
+  buildRedeemTx(vaultId, body) {
+    return this.post(`/vaults/${vaultId}/tx/redeem`, body);
+  }
+  buildClaimTx(vaultId, body) {
+    return this.post(`/vaults/${vaultId}/tx/claim`, body);
+  }
+  buildCancelDepositTx(vaultId, body) {
+    return this.post(`/vaults/${vaultId}/tx/cancel-deposit`, body);
+  }
+  async confirmIntent(intentId, digest) {
+    return this.post(`/transactions/${intentId}/confirm`, { digest });
+  }
+  async post(endpoint, body) {
+    const response = await this.fetcher(`${this.baseUrl}${endpoint}`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => void 0);
+      const message = error?.error?.message ?? error?.message ?? response.statusText ?? `HTTP ${response.status}`;
+      throw new TBookSuiVaultReactError("API_ERROR", message);
+    }
+    return response.json();
+  }
+  headers() {
+    return {
+      "Content-Type": "application/json",
+      ...this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : {}
+    };
+  }
+};
+
+// src/vault-info.ts
+function balanceValue(value) {
+  return BigInt(value?.value ?? value ?? "0");
+}
+function boolValue(value) {
+  return value === true || value === "true";
+}
+function fieldsFromMoveObject(obj, label) {
+  const content = obj.data?.content;
+  if (!content || content.dataType !== "moveObject") {
+    throw new Error(`Invalid ${label} object`);
+  }
+  return content.fields;
+}
+async function getSuiVaultInfo(client, cfg) {
+  const [vaultObj, depositStateObj] = await Promise.all([
+    client.getObject({ id: cfg.vaultObjectId, options: { showContent: true } }),
+    client.getObject({ id: cfg.depositSettlementStateId, options: { showContent: true } })
+  ]);
+  const fields = fieldsFromMoveObject(vaultObj, "vault");
+  let depositSettlementActive = false;
+  try {
+    const depositStateFields = fieldsFromMoveObject(depositStateObj, "deposit settlement state");
+    depositSettlementActive = boolValue(depositStateFields.active);
+  } catch {
+    depositSettlementActive = false;
+  }
+  return {
+    totalShares: BigInt(fields.total_shares ?? "0"),
+    pendingDeposit: balanceValue(fields.pending_deposit),
+    claimReserve: balanceValue(fields.claim_reserve),
+    rcusdpCustody: balanceValue(fields.rcusdp_custody),
+    pendingRedeemRcusdp: balanceValue(fields.pending_redeem_rcusdp),
+    reserveFund: balanceValue(fields.reserve_fund),
+    depositFeeBps: BigInt(fields.deposit_fee_bps ?? "0"),
+    mgmtFeeBps: BigInt(fields.mgmt_fee_bps ?? "0"),
+    redeemFeeBps: BigInt(fields.redeem_fee_bps ?? "0"),
+    withdrawFeeBps: BigInt(fields.withdraw_fee_bps ?? "0"),
+    cancelDepositFeeBps: BigInt(fields.cancel_deposit_fee_bps ?? "0"),
+    instantRedeemFeeBps: BigInt(fields.instant_redeem_fee_bps ?? "0"),
+    paused: boolValue(fields.paused),
+    version: BigInt(fields.version ?? "1"),
+    depositEnabled: !depositSettlementActive,
+    instantRedeemEnabled: boolValue(fields.instant_redeem_enabled),
+    withdrawRcusdpEnabled: boolValue(fields.withdraw_rcusdp_enabled),
+    cancelDepositEnabled: boolValue(fields.cancel_deposit_enabled),
+    redeemSettled: boolValue(fields.redeem_settled),
+    raw: fields
+  };
+}
+
+// src/hooks/use-vault-config.ts
+var useSuiVaultConfig = useTBookSuiVault;
+function useSuiVaultInfo(options) {
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  return reactQuery.useQuery({
+    queryKey: suiVaultQueryKeys.vaultInfo(config.network, config.vaultId),
+    queryFn: () => getSuiVaultInfo(client, config.vault),
+    staleTime: config.staleTimes.vaultInfo,
+    refetchInterval: config.refetchIntervals.vaultInfo,
+    enabled: Boolean(config.vault.vaultObjectId) && (options?.enabled ?? true),
+    ...options
+  });
+}
+function useSuiVaultBalances(options) {
+  const account = dappKit.useCurrentAccount();
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  return reactQuery.useQuery({
+    queryKey: suiVaultQueryKeys.balances(config.network, config.vaultId, account?.address ?? ""),
+    queryFn: async () => {
+      if (!account?.address) {
+        throw new Error("Wallet not connected");
+      }
+      return vaultSdkSui.getUserPosition(client, config.vault, account.address);
+    },
+    enabled: Boolean(account?.address) && (options?.enabled ?? true),
+    staleTime: config.staleTimes.balances,
+    refetchInterval: config.refetchIntervals.balances,
+    ...options
+  });
+}
+function useSuiTransactionHistory(options) {
+  const account = dappKit.useCurrentAccount();
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  return reactQuery.useQuery({
+    queryKey: suiVaultQueryKeys.history(config.network, config.vaultId, account?.address ?? ""),
+    queryFn: async () => {
+      if (!account?.address) return [];
+      return vaultSdkSui.getUserRecords(client, config.vault, account.address);
+    },
+    enabled: Boolean(account?.address) && (options?.enabled ?? true),
+    staleTime: config.staleTimes.history,
+    refetchInterval: config.refetchIntervals.history,
+    ...options
+  });
+}
+function useSuiUsdcBalance(options) {
+  const account = dappKit.useCurrentAccount();
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  const query = reactQuery.useQuery({
+    queryKey: suiVaultQueryKeys.usdcBalance(
+      config.network,
+      account?.address ?? "",
+      config.vault.usdcType
+    ),
+    queryFn: async () => {
+      if (!account?.address) {
+        throw new Error("Wallet not connected");
+      }
+      return client.getBalance({ owner: account.address, coinType: config.vault.usdcType });
+    },
+    enabled: Boolean(account?.address) && (options?.enabled ?? true),
+    staleTime: config.staleTimes.usdcBalance,
+    refetchInterval: config.refetchIntervals.usdcBalance,
+    ...options
+  });
+  const balance = BigInt(query.data?.totalBalance ?? "0");
+  return {
+    ...query,
+    balance,
+    decimals: vaultSdkSui.USDC_DECIMALS,
+    formatted: formatRawAmount(balance, vaultSdkSui.USDC_DECIMALS)
+  };
+}
+function useRefreshSuiVaultData() {
+  const account = dappKit.useCurrentAccount();
+  const queryClient = reactQuery.useQueryClient();
+  const config = useTBookSuiVault();
+  return async () => {
+    await Promise.all([
+      queryClient.invalidateQueries({
+        queryKey: suiVaultQueryKeys.vault(config.network, config.vaultId)
+      }),
+      account?.address ? queryClient.invalidateQueries({
+        queryKey: suiVaultQueryKeys.balances(config.network, config.vaultId, account.address)
+      }) : Promise.resolve(),
+      account?.address ? queryClient.invalidateQueries({
+        queryKey: suiVaultQueryKeys.history(config.network, config.vaultId, account.address)
+      }) : Promise.resolve(),
+      account?.address ? queryClient.invalidateQueries({
+        queryKey: suiVaultQueryKeys.usdcBalance(
+          config.network,
+          account.address,
+          config.vault.usdcType
+        )
+      }) : Promise.resolve()
+    ]);
+  };
+}
+function redeemMode(params) {
+  if (params.mode) return params.mode;
+  return params.tokenType === "RCUSDP" ? "instant" : "queued";
+}
+async function executeTx(signAndExecuteTransaction, result) {
+  return signAndExecuteTransaction({ transaction: result.txBytesBase64 });
+}
+function gatewayClient(config) {
+  if (!config.gatewayApiBaseUrl) {
+    throw new TBookSuiVaultReactError(
+      "CONFIGURATION_ERROR",
+      "gatewayApiBaseUrl is required for gateway-api transaction building"
+    );
+  }
+  return new TBookSuiGatewayApiClient({
+    baseUrl: config.gatewayApiBaseUrl,
+    apiKey: config.publishableKey
+  });
+}
+function assertVaultCanDeposit(info) {
+  if (!info) return;
+  if (info.paused) throw new TBookSuiVaultReactError("VAULT_PAUSED", "Vault is paused");
+  if (!info.depositEnabled) {
+    throw new TBookSuiVaultReactError("SETTLEMENT_ACTIVE", "Deposits are temporarily unavailable");
+  }
+}
+function assertVaultCanRedeem(info) {
+  if (!info) return;
+  if (info.paused) throw new TBookSuiVaultReactError("VAULT_PAUSED", "Vault is paused");
+}
+function assertVaultCanCancel(info) {
+  if (!info) return;
+  if (info.paused) throw new TBookSuiVaultReactError("VAULT_PAUSED", "Vault is paused");
+  if (!info.cancelDepositEnabled) {
+    throw new TBookSuiVaultReactError("SETTLEMENT_ACTIVE", "Cancel deposit is unavailable");
+  }
+}
+function useSuiDeposit() {
+  const account = dappKit.useCurrentAccount();
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  const { mutateAsync: signAndExecuteTransaction } = dappKit.useSignAndExecuteTransaction();
+  const refresh = useRefreshSuiVaultData();
+  const { data: vaultInfo } = useSuiVaultInfo({ enabled: config.preflightChecks });
+  return reactQuery.useMutation({
+    mutationFn: async ({ amount }) => {
+      if (!account?.address) throw walletNotConnected();
+      if (config.preflightChecks) assertVaultCanDeposit(vaultInfo);
+      const raw = toRawAmount(amount);
+      if (config.txBuilderMode === "gateway-api") {
+        const api = gatewayClient(config);
+        const response = await api.buildDepositTx(config.vaultId, {
+          user: account.address,
+          amount: formatRawAmount(raw)
+        });
+        const tx = await signAndExecuteTransaction({ transaction: response.transaction.data });
+        if (response.intentId && tx.digest) {
+          await api.confirmIntent(response.intentId, tx.digest);
+        }
+        return tx;
+      }
+      const result = config.txBuilderMode === "custom" ? await config.customTxBuilder?.buildDepositTx?.({ sender: account.address, amount: raw }) : await vaultSdkSui.buildDepositTx(client, config.vault, { sender: account.address, amount: raw });
+      if (!result) {
+        throw new TBookSuiVaultReactError("UNSUPPORTED_TX_BUILDER", "Deposit builder is not configured");
+      }
+      return executeTx(signAndExecuteTransaction, result);
+    },
+    onSuccess: refresh
+  });
+}
+function useSuiRedeem() {
+  const account = dappKit.useCurrentAccount();
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  const { mutateAsync: signAndExecuteTransaction } = dappKit.useSignAndExecuteTransaction();
+  const refresh = useRefreshSuiVaultData();
+  const { data: vaultInfo } = useSuiVaultInfo({ enabled: config.preflightChecks });
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!account?.address) throw walletNotConnected();
+      if (config.preflightChecks) assertVaultCanRedeem(vaultInfo);
+      const mode = redeemMode(params);
+      const shares = toRawAmount(params.shares);
+      if (config.txBuilderMode === "gateway-api") {
+        const api = gatewayClient(config);
+        const response = await api.buildRedeemTx(config.vaultId, {
+          user: account.address,
+          shares: formatRawAmount(shares),
+          mode
+        });
+        const tx = await signAndExecuteTransaction({ transaction: response.transaction.data });
+        if (response.intentId && tx.digest) {
+          await api.confirmIntent(response.intentId, tx.digest);
+        }
+        return tx;
+      }
+      const result = config.txBuilderMode === "custom" ? mode === "instant" ? await config.customTxBuilder?.buildInstantRedeemTx?.({ sender: account.address, shares }) : await config.customTxBuilder?.buildQueueRedeemTx?.({ sender: account.address, shares }) : mode === "instant" ? await vaultSdkSui.buildInstantRedeemTx(client, config.vault, { sender: account.address, shares }) : await vaultSdkSui.buildQueueRedeemTx(client, config.vault, { sender: account.address, shares });
+      if (!result) {
+        throw new TBookSuiVaultReactError("UNSUPPORTED_TX_BUILDER", "Redeem builder is not configured");
+      }
+      return executeTx(signAndExecuteTransaction, result);
+    },
+    onSuccess: refresh
+  });
+}
+function useSuiClaim() {
+  const account = dappKit.useCurrentAccount();
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  const { mutateAsync: signAndExecuteTransaction } = dappKit.useSignAndExecuteTransaction();
+  const refresh = useRefreshSuiVaultData();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!account?.address) throw walletNotConnected();
+      const amount = params?.amount === void 0 ? void 0 : toRawAmount(params.amount);
+      if (config.txBuilderMode === "gateway-api") {
+        const api = gatewayClient(config);
+        const response = await api.buildClaimTx(config.vaultId, { user: account.address });
+        const tx = await signAndExecuteTransaction({ transaction: response.transaction.data });
+        if (response.intentId && tx.digest) {
+          await api.confirmIntent(response.intentId, tx.digest);
+        }
+        return tx;
+      }
+      const result = config.txBuilderMode === "custom" ? await config.customTxBuilder?.buildClaimTx?.({ sender: account.address, amount }) : await vaultSdkSui.buildClaimTx(client, config.vault, { sender: account.address, amount });
+      if (!result) {
+        throw new TBookSuiVaultReactError("UNSUPPORTED_TX_BUILDER", "Claim builder is not configured");
+      }
+      return executeTx(signAndExecuteTransaction, result);
+    },
+    onSuccess: refresh
+  });
+}
+function useSuiCancelDeposit() {
+  const account = dappKit.useCurrentAccount();
+  const client = dappKit.useSuiClient();
+  const config = useTBookSuiVault();
+  const { mutateAsync: signAndExecuteTransaction } = dappKit.useSignAndExecuteTransaction();
+  const refresh = useRefreshSuiVaultData();
+  const { data: vaultInfo } = useSuiVaultInfo({ enabled: config.preflightChecks });
+  return reactQuery.useMutation({
+    mutationFn: async ({ recordId }) => {
+      if (!account?.address) throw walletNotConnected();
+      if (config.preflightChecks) assertVaultCanCancel(vaultInfo);
+      if (config.txBuilderMode === "gateway-api") {
+        const api = gatewayClient(config);
+        const response = await api.buildCancelDepositTx(config.vaultId, {
+          user: account.address,
+          recordId: String(recordId)
+        });
+        const tx = await signAndExecuteTransaction({ transaction: response.transaction.data });
+        if (response.intentId && tx.digest) {
+          await api.confirmIntent(response.intentId, tx.digest);
+        }
+        return tx;
+      }
+      const result = config.txBuilderMode === "custom" ? await config.customTxBuilder?.buildCancelDepositTx?.({ sender: account.address, recordId }) : await vaultSdkSui.buildCancelDepositTx(client, config.vault, { sender: account.address, recordId });
+      if (!result) {
+        throw new TBookSuiVaultReactError("UNSUPPORTED_TX_BUILDER", "Cancel deposit builder is not configured");
+      }
+      return executeTx(signAndExecuteTransaction, result);
+    },
+    onSuccess: refresh
+  });
+}
+
+exports.DEFAULT_SUI_VAULT_ID = DEFAULT_SUI_VAULT_ID;
+exports.SUI_TESTNET_GATEWAY_API_BASE_URL = SUI_TESTNET_GATEWAY_API_BASE_URL;
+exports.TBookSuiGatewayApiClient = TBookSuiGatewayApiClient;
+exports.TBookSuiVaultProvider = TBookSuiVaultProvider;
+exports.TBookSuiVaultReactError = TBookSuiVaultReactError;
+exports.createSuiVaultConfig = createSuiVaultConfig;
+exports.formatRawAmount = formatRawAmount;
+exports.getSuiVaultInfo = getSuiVaultInfo;
+exports.parseDecimalAmount = parseDecimalAmount;
+exports.suiVaultQueryKeys = suiVaultQueryKeys;
+exports.toRawAmount = toRawAmount;
+exports.useRefreshSuiVaultData = useRefreshSuiVaultData;
+exports.useSuiCancelDeposit = useSuiCancelDeposit;
+exports.useSuiClaim = useSuiClaim;
+exports.useSuiDeposit = useSuiDeposit;
+exports.useSuiRedeem = useSuiRedeem;
+exports.useSuiTransactionHistory = useSuiTransactionHistory;
+exports.useSuiUsdcBalance = useSuiUsdcBalance;
+exports.useSuiVaultBalances = useSuiVaultBalances;
+exports.useSuiVaultConfig = useSuiVaultConfig;
+exports.useSuiVaultInfo = useSuiVaultInfo;
+exports.useTBookSuiVault = useTBookSuiVault;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map