@agg-build/hooks 1.0.0 → 1.0.2

package/README.md

@@ -393,7 +393,7 @@ Optional (only needed for wallet-based sign-in / deposits):
 ## Links
 
 - Documentation — <https://docs.agg.market/>
-- Demo app — <https://demo.agg.market/>
+- Demo app — <https://agg.market/>
 - Vanilla SDK — [`@agg-build/sdk`](https://www.npmjs.com/package/@agg-build/sdk)
 - Trading UI — [`@agg-build/ui`](https://www.npmjs.com/package/@agg-build/ui)
 - Connect / sign-in UX — [`@agg-build/auth`](https://www.npmjs.com/package/@agg-build/auth)

package/dist/chunk-EB64HHYM.mjs

@@ -0,0 +1,31 @@
+import {
+  __async,
+  useAggClient
+} from "./chunk-V6VNA7MX.mjs";
+
+// src/use-ramp-quotes.ts
+import { useMutation } from "@tanstack/react-query";
+function useRampQuotes() {
+  const client = useAggClient();
+  return useMutation({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.getRampQuotes(params);
+    })
+  });
+}
+
+// src/use-ramp-session.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function useRampSession() {
+  const client = useAggClient();
+  return useMutation2({
+    mutationFn: (params) => __async(null, null, function* () {
+      return client.createRampSession(params);
+    })
+  });
+}
+
+export {
+  useRampQuotes,
+  useRampSession
+};

package/dist/chunk-NOYHQUW2.mjs

@@ -0,0 +1,389 @@
+import {
+  __async,
+  invalidateBalanceQueries,
+  useAggBalanceState,
+  useAggClient,
+  useAggWebSocket,
+  useAggWebSocketConnectionState,
+  useDepositAddresses,
+  useManagedBalances,
+  useOnWithdrawalLifecycle,
+  useSyncBalances,
+  useWithdrawManaged
+} from "./chunk-V6VNA7MX.mjs";
+
+// src/withdraw/use-withdraw-flow.ts
+import { useCallback, useEffect, useMemo, useState } from "react";
+var EVM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+var SOLANA_ADDRESS_REGEX = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+var SOLANA_CHAIN_ID = 792703809;
+var WITHDRAWAL_SUPPORTED_CHAIN_IDS = /* @__PURE__ */ new Set([
+  1,
+  // Ethereum
+  137,
+  // Polygon
+  42161,
+  // Arbitrum
+  8453,
+  // Base
+  56,
+  // BNB
+  SOLANA_CHAIN_ID
+]);
+var isValidDestinationAddress = (address, chainId) => {
+  if (chainId === SOLANA_CHAIN_ID) return SOLANA_ADDRESS_REGEX.test(address);
+  return EVM_ADDRESS_REGEX.test(address);
+};
+var DEFAULT_WITHDRAW_SUMMARY = {
+  amountReceived: "",
+  network: "",
+  toWallet: "",
+  fees: "\u2014"
+};
+var formatRawTokenAmount = (rawAmount, decimals) => {
+  if (!rawAmount) return "0";
+  const raw = BigInt(rawAmount);
+  const divisor = BigInt(`1${"0".repeat(decimals)}`);
+  const whole = raw / divisor;
+  const remainder = raw % divisor;
+  if (remainder === BigInt(0)) return whole.toString();
+  return `${whole.toString()}.${remainder.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
+var formatRawTokenAmountForDisplay = (rawAmount, decimals, fractionDigits = 2) => {
+  const [wholePart, fractionalPart = ""] = formatRawTokenAmount(rawAmount, decimals).split(".");
+  const normalizedFraction = fractionalPart.padEnd(fractionDigits, "0").slice(0, fractionDigits);
+  return `${wholePart}.${normalizedFraction}`;
+};
+var parseTokenAmountToRaw = (amount, decimals) => {
+  const normalizedAmount = amount.trim();
+  if (!normalizedAmount || !/^\d*(?:\.\d*)?$/.test(normalizedAmount)) {
+    return null;
+  }
+  const [wholePart = "0", fractionalPart = ""] = normalizedAmount.split(".");
+  if (fractionalPart.length > decimals) return null;
+  const normalizedWhole = wholePart === "" ? "0" : wholePart;
+  const normalizedFraction = fractionalPart.padEnd(decimals, "0");
+  try {
+    return `${BigInt(normalizedWhole)}${normalizedFraction}`.replace(/^0+(?=\d)/, "");
+  } catch (e) {
+    return null;
+  }
+};
+var shortenAddress = (address) => address.length > 12 ? `${address.slice(0, 6)}...${address.slice(-4)}` : address;
+function useWithdrawFlow(options) {
+  var _a, _b;
+  const { open, onOpenChange } = options;
+  const { totalBalance } = useAggBalanceState();
+  const { balances } = useManagedBalances({ enabled: open });
+  const { supportedChains } = useDepositAddresses({ enabled: open });
+  const withdrawMutation = useWithdrawManaged();
+  const syncBalances = useSyncBalances();
+  const ws = useAggWebSocket();
+  useEffect(() => {
+    if (!open) return;
+    syncBalances.mutate(void 0, {
+      onError: () => {
+      }
+    });
+  }, [open]);
+  const [withdrawDestination, setWithdrawDestination] = useState("");
+  const [withdrawAmount, setWithdrawAmount] = useState("");
+  const [withdrawToken, setWithdrawToken] = useState("USDC");
+  const [withdrawNetwork, setWithdrawNetwork] = useState("");
+  const [withdrawSummary, setWithdrawSummary] = useState(DEFAULT_WITHDRAW_SUMMARY);
+  const [withdrawalId, setWithdrawalId] = useState(null);
+  const networkOptions = useMemo(
+    () => (supportedChains != null ? supportedChains : []).filter((chain) => WITHDRAWAL_SUPPORTED_CHAIN_IDS.has(chain.chainId)).map((chain) => ({
+      value: String(chain.chainId),
+      label: chain.name
+    })),
+    [supportedChains]
+  );
+  const resolvedWithdrawNetwork = withdrawNetwork || ((_a = networkOptions[0]) == null ? void 0 : _a.value) || "";
+  useEffect(() => {
+    if (!networkOptions.length) return;
+    if (!withdrawNetwork || !networkOptions.some((option) => option.value === withdrawNetwork)) {
+      setWithdrawNetwork(networkOptions[0].value);
+    }
+  }, [networkOptions, withdrawNetwork]);
+  const tokenOptions = useMemo(() => {
+    var _a2, _b2, _c;
+    const selectedChainId = Number(resolvedWithdrawNetwork);
+    const supportedTokensForNetwork = (_b2 = (_a2 = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === selectedChainId)) == null ? void 0 : _a2.tokens) != null ? _b2 : [];
+    const withdrawableSymbols = new Set(supportedTokensForNetwork.map((token) => token.symbol));
+    return ((_c = balances == null ? void 0 : balances.cash) != null ? _c : []).filter((cashEntry) => withdrawableSymbols.has(cashEntry.tokenSymbol)).map((cashEntry) => ({
+      value: cashEntry.tokenSymbol,
+      label: cashEntry.tokenSymbol
+    }));
+  }, [balances, resolvedWithdrawNetwork, supportedChains]);
+  const resolvedWithdrawToken = tokenOptions.some((option) => option.value === withdrawToken) ? withdrawToken : ((_b = tokenOptions[0]) == null ? void 0 : _b.value) || "";
+  useEffect(() => {
+    if (!tokenOptions.length) return;
+    if (!tokenOptions.some((option) => option.value === withdrawToken)) {
+      setWithdrawToken(tokenOptions[0].value);
+    }
+  }, [tokenOptions, withdrawToken]);
+  const selectedCashEntry = useMemo(
+    () => balances == null ? void 0 : balances.cash.find((cashEntry) => cashEntry.tokenSymbol === resolvedWithdrawToken),
+    [balances, resolvedWithdrawToken]
+  );
+  const selectedTokenDecimals = useMemo(() => {
+    var _a2, _b2, _c, _d;
+    const selectedChainId = Number(resolvedWithdrawNetwork);
+    return (_d = (_c = (_b2 = (_a2 = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === selectedChainId)) == null ? void 0 : _a2.tokens.find((token) => token.symbol === resolvedWithdrawToken)) == null ? void 0 : _b2.decimals) != null ? _c : selectedCashEntry == null ? void 0 : selectedCashEntry.decimals) != null ? _d : 6;
+  }, [
+    resolvedWithdrawNetwork,
+    resolvedWithdrawToken,
+    selectedCashEntry == null ? void 0 : selectedCashEntry.decimals,
+    supportedChains
+  ]);
+  const exactBalance = useMemo(() => {
+    if (!selectedCashEntry) return "0";
+    return formatRawTokenAmount(selectedCashEntry.totalRaw, selectedCashEntry.decimals);
+  }, [selectedCashEntry]);
+  const balanceDisplay = useMemo(() => {
+    if (!selectedCashEntry) return `0.00 ${resolvedWithdrawToken || withdrawToken}`;
+    return `${formatRawTokenAmountForDisplay(
+      selectedCashEntry.totalRaw,
+      selectedCashEntry.decimals
+    )} ${resolvedWithdrawToken}`;
+  }, [resolvedWithdrawToken, selectedCashEntry, withdrawToken]);
+  const resetFlowState = useCallback(() => {
+    setWithdrawDestination("");
+    setWithdrawAmount("");
+    setWithdrawToken("USDC");
+    setWithdrawNetwork("");
+    setWithdrawSummary(DEFAULT_WITHDRAW_SUMMARY);
+    setWithdrawalId(null);
+  }, []);
+  const handleWithdrawOpenChange = useCallback(
+    (isOpen) => {
+      if (!isOpen) resetFlowState();
+      onOpenChange(isOpen);
+    },
+    [onOpenChange, resetFlowState]
+  );
+  useEffect(() => {
+    if (!open) resetFlowState();
+  }, [open, resetFlowState]);
+  const handleWithdrawProvider = useCallback(() => __async(null, null, function* () {
+    var _a2, _b2;
+    const destinationChainId = Number(resolvedWithdrawNetwork);
+    const trimmedDestination = withdrawDestination.trim();
+    const amountRaw = parseTokenAmountToRaw(withdrawAmount, selectedTokenDecimals);
+    if (!amountRaw || BigInt(amountRaw) <= BigInt(0)) {
+      throw new Error("Enter a withdrawal amount greater than zero.");
+    }
+    if (!Number.isFinite(destinationChainId) || destinationChainId <= 0) {
+      throw new Error("Select a destination network.");
+    }
+    if (!isValidDestinationAddress(trimmedDestination, destinationChainId)) {
+      const expected = destinationChainId === SOLANA_CHAIN_ID ? "a Solana wallet address (base58, 32\u201344 chars)" : "an EVM destination address (0x\u2026 40 hex chars)";
+      throw new Error(`Enter ${expected}.`);
+    }
+    if (selectedCashEntry) {
+      const scaleBy = (n, exp) => {
+        if (exp <= 0) return n;
+        return n * BigInt(`1${"0".repeat(exp)}`);
+      };
+      const balanceInDestFrame = (() => {
+        const native = BigInt(selectedCashEntry.totalRaw);
+        if (selectedCashEntry.decimals === selectedTokenDecimals) return native;
+        if (selectedCashEntry.decimals > selectedTokenDecimals) {
+          return native / scaleBy(BigInt(1), selectedCashEntry.decimals - selectedTokenDecimals);
+        }
+        return scaleBy(native, selectedTokenDecimals - selectedCashEntry.decimals);
+      })();
+      if (BigInt(amountRaw) > balanceInDestFrame) {
+        throw new Error("Withdrawal amount exceeds your available balance.");
+      }
+    }
+    ws == null ? void 0 : ws.connect();
+    yield new Promise((resolve, reject) => {
+      withdrawMutation.mutate(
+        {
+          amountRaw,
+          tokenSymbol: resolvedWithdrawToken,
+          destinationAddress: trimmedDestination,
+          destinationChainId
+        },
+        {
+          onSuccess: (data) => {
+            setWithdrawalId(data.withdrawalId);
+            resolve();
+          },
+          onError: reject
+        }
+      );
+    });
+    setWithdrawSummary({
+      amountReceived: `${formatRawTokenAmountForDisplay(amountRaw, selectedTokenDecimals)} ${resolvedWithdrawToken}`,
+      network: (_b2 = (_a2 = supportedChains == null ? void 0 : supportedChains.find((chain) => chain.chainId === destinationChainId)) == null ? void 0 : _a2.name) != null ? _b2 : resolvedWithdrawNetwork,
+      toWallet: shortenAddress(trimmedDestination),
+      fees: "\u2014"
+    });
+  }), [
+    resolvedWithdrawNetwork,
+    resolvedWithdrawToken,
+    selectedCashEntry,
+    selectedTokenDecimals,
+    supportedChains,
+    withdrawAmount,
+    withdrawDestination,
+    withdrawMutation,
+    ws
+  ]);
+  return {
+    open,
+    onOpenChange: handleWithdrawOpenChange,
+    withdrawFlow: {
+      balance: totalBalance,
+      balanceDisplay,
+      amount: withdrawAmount,
+      destinationWallet: withdrawDestination,
+      tokenOptions,
+      networkOptions,
+      selectedToken: resolvedWithdrawToken,
+      selectedNetwork: resolvedWithdrawNetwork,
+      purchaseSummary: withdrawSummary,
+      withdrawalId
+    },
+    onWithdrawDestinationChange: setWithdrawDestination,
+    onWithdrawAmountChange: setWithdrawAmount,
+    onWithdrawTokenChange: setWithdrawToken,
+    onWithdrawNetworkChange: setWithdrawNetwork,
+    onMaxClick: useCallback(() => {
+      setWithdrawAmount(exactBalance === "0" ? "0" : exactBalance);
+    }, [exactBalance]),
+    onSelectWithdrawProvider: useCallback(
+      (_providerId) => __async(null, null, function* () {
+        return handleWithdrawProvider();
+      }),
+      [handleWithdrawProvider]
+    ),
+    onDoneWithdraw: useCallback(() => handleWithdrawOpenChange(false), [handleWithdrawOpenChange])
+  };
+}
+
+// src/withdraw/use-withdrawal-lifecycle.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo2, useRef, useState as useState2 } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+var INITIAL_STATE = {
+  pending: true,
+  status: null,
+  terminal: false,
+  lastLeg: null,
+  legs: [],
+  errorMessage: null,
+  timestamp: null
+};
+var restLegToWsLeg = (leg) => ({
+  sourceChainId: leg.sourceChainId,
+  destChainId: leg.destChainId,
+  type: leg.type,
+  // The wire-level WS leg status enum and the REST leg status enum are the
+  // same union (planned/submitted/confirmed/failed). Keep the cast narrow to
+  // avoid pulling the SDK enum apart for a one-line bridge.
+  status: leg.status,
+  amountRaw: leg.amountRaw,
+  txHash: leg.txHash,
+  bridgeOperationId: leg.bridgeOperationId
+});
+var mergeLegs = (prev, snapshot, delta) => {
+  if (snapshot) return snapshot;
+  if (!delta) return prev;
+  const idx = prev.findIndex(
+    (l) => l.sourceChainId === delta.sourceChainId && l.destChainId === delta.destChainId && l.type === delta.type
+  );
+  if (idx === -1) return [...prev, delta];
+  const next = prev.slice();
+  next[idx] = delta;
+  return next;
+};
+var restToLifecycleState = (response) => {
+  var _a;
+  return {
+    pending: false,
+    status: response.status,
+    terminal: response.status === "completed" || response.status === "partial" || response.status === "failed",
+    lastLeg: null,
+    legs: response.legs.map(restLegToWsLeg),
+    errorMessage: (_a = response.errorMessage) != null ? _a : null,
+    // No server timestamp on the REST response — we use 0 as "older than any
+    // WS timestamp" so a subsequent WS event always wins. Callers that read
+    // `timestamp` should treat 0/null interchangeably as "unset".
+    timestamp: 0
+  };
+};
+function useWithdrawalLifecycle(withdrawalId) {
+  const client = useAggClient();
+  const wsConnected = useAggWebSocketConnectionState();
+  const queryClient = useQueryClient();
+  const [state, setState] = useState2(INITIAL_STATE);
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  const balanceRefetchedForRef = useRef(null);
+  useEffect2(() => {
+    setState(INITIAL_STATE);
+  }, [withdrawalId]);
+  useEffect2(() => {
+    if (!withdrawalId) return;
+    let cancelled = false;
+    (() => __async(null, null, function* () {
+      try {
+        const response = yield client.getWithdrawalStatus(withdrawalId);
+        if (cancelled) return;
+        if (response.withdrawalId !== withdrawalId) return;
+        const current = stateRef.current;
+        const wsAlreadyWon = current.timestamp != null && current.timestamp > 0;
+        if (wsAlreadyWon) return;
+        setState(restToLifecycleState(response));
+      } catch (e) {
+      }
+    }))();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, withdrawalId, wsConnected]);
+  const handler = useMemo2(() => {
+    if (!withdrawalId) return null;
+    return (msg) => {
+      if (msg.withdrawalId !== withdrawalId) return;
+      setState((prev) => {
+        var _a, _b;
+        return {
+          pending: false,
+          status: msg.status,
+          terminal: msg.terminal,
+          lastLeg: (_a = msg.leg) != null ? _a : null,
+          // `legs[]` is the cumulative server-known truth. Snapshots
+          // (`pending` / terminal rollup) carry a full `legs[]` and replace
+          // it. Intermediate per-leg deltas carry only `leg` (no `legs[]`)
+          // — merge the delta into the existing array by
+          // (sourceChainId, destChainId, type) so the timeline UI doesn't
+          // collapse to empty between snapshots.
+          legs: mergeLegs(prev.legs, msg.legs, msg.leg),
+          errorMessage: (_b = msg.errorMessage) != null ? _b : null,
+          timestamp: msg.timestamp
+        };
+      });
+    };
+  }, [withdrawalId]);
+  useOnWithdrawalLifecycle(handler);
+  useEffect2(() => {
+    if (!withdrawalId) return;
+    if (!state.terminal) return;
+    if (balanceRefetchedForRef.current === withdrawalId) return;
+    balanceRefetchedForRef.current = withdrawalId;
+    invalidateBalanceQueries(queryClient);
+    client.syncManagedBalances().catch(() => {
+    });
+  }, [client, queryClient, state.terminal, withdrawalId]);
+  const reset = useCallback2(() => setState(INITIAL_STATE), []);
+  return { state, reset };
+}
+
+export {
+  useWithdrawFlow,
+  useWithdrawalLifecycle
+};