chore: create hooks

.gitignore

@@ -13,6 +13,7 @@ dist
 dist-ssr
 *.tgz
 *.local
+demo
 
 # Editor directories and files
 .vscode/*

package.json

@@ -31,6 +31,7 @@
   },
   "peerDependencies": {
     "@bluxcc/core": "^0.1.16",
+    "@tanstack/react-query": "^5.90.11",
     "react": ">=17.0.0",
     "react-dom": ">=17.0.0"
   },

src/useStellar/index.ts

@@ -1,13 +1,13 @@
 export { networks } from '@bluxcc/core';
 export * from './useAccount';
 export * from './useNetwork';
-// import useAccounts from './useAccounts';
-// import useAssets from './useAssets';
-// import useBalances from './useBalances';
-// import useClaimableBalances from './useClaimableBalances';
-// import useEffects from './useEffects';
-// import useLedgers from './useLedgers';
-// import useLiquidityPools from './useLiquidityPools';
+export * from './useAccounts';
+// export * from './useAssets';
+export * from './useBalances';
+export * from './useClaimableBalances';
+export * from './useEffects';
+export * from './useLedgers';
+export * from './useLiquidityPools';
 // import useNetwork from './useNetwork';
 // import useOffers from './useOffers';
 // import useOperations from './useOperations';
@@ -17,5 +17,5 @@ export * from './useNetwork';
 // import useStrictSendPaths from './useStrictSendPaths';
 // import useTradeAggregation from './useTradeAggregation';
 // import useTrades from './useTrades';
-// import useTransactions from './useTransactions';
+// export * from './useTransactions';
 export { useSwitchNetwork } from './useSwitchNetwork';

src/useStellar/useAccount.ts

@@ -12,9 +12,6 @@ export type UseAccountResult = {
 };
 
 export function useAccount(options: GetAccountOptions): UseAccountResult {
-  // TODO: we need the same exact function as the core function here.
-  // Take the options.address, options.network, pass it to it, and wait for changes
-  // In useEffect.
   const [result, setResult] = useState<GetAccountResult>(null);
   const [error, setError] = useState<Error | null>(null);
   const [loading, setLoading] = useState<boolean>(false);

src/useStellar/useAccounts.ts

@@ -0,0 +1,51 @@
+import { useState, useEffect } from "react";
+import { getAccounts } from "@bluxcc/core"; // or your local path
+import {
+  GetAccountsOptions,
+  GetAccountsResult,
+} from "@bluxcc/core/dist/exports/core/getAccounts";
+
+export type UseAccountsResult = {
+  loading: boolean;
+  error: Error | null;
+  result: GetAccountsResult | null;
+};
+
+export function useAccounts(options: GetAccountsOptions): UseAccountsResult {
+  const [result, setResult] = useState<GetAccountsResult | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [loading, setLoading] = useState<boolean>(false);
+
+  useEffect(() => {
+    if (!options.network) return;
+
+    const fetchAccounts = async () => {
+      setLoading(true);
+      setError(null);
+
+      try {
+        const accounts = await getAccounts(options);
+        setResult(accounts);
+      } catch (e) {
+        setError(e instanceof Error ? e : new Error(String(e)));
+        setResult(null);
+      } finally {
+        setLoading(false);
+      }
+    };
+
+    fetchAccounts();
+  }, [
+    options.network,
+    options.forSigner,
+    options.forAsset?.code,
+    options.forAsset?.issuer,
+    options.forLiquidityPool,
+    options.sponsor,
+    options.cursor,
+    options.limit,
+    options.order,
+  ]);
+
+  return { loading, error, result };
+}

src/useStellar/useAssets.ts

@@ -0,0 +1,55 @@
+// Upon testing, it either gives "Bad Request" or "Custom network has no transports."
+
+import { useEffect, useState } from "react";
+import { getAssets } from "@bluxcc/core";
+
+import {
+  GetAssetsOptions,
+  GetAssetsResult,
+} from "@bluxcc/core/dist/exports/core/getAssets";
+
+export type UseAssetsResult = {
+  loading: boolean;
+  error: Error | null;
+  result: GetAssetsResult | null;
+};
+
+export function useAssets(options: GetAssetsOptions): UseAssetsResult {
+  const [result, setResult] = useState<GetAssetsResult | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    setLoading(true);
+    setError(null);
+
+    getAssets(options)
+      .then((r) => {
+        if (!cancelled) {
+          setResult(r);
+          setLoading(false);
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          setError(err);
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    options.network,
+    options.cursor,
+    options.limit,
+    options.order,
+    options.forCode,
+    options.forIssuer,
+  ]);
+
+  return { loading, error, result };
+}

src/useStellar/useBalances.ts

@@ -0,0 +1,53 @@
+import { useMemo } from "react";
+import { useQuery, UseQueryOptions, UseQueryResult } from "@tanstack/react-query";
+import { getBalances } from "@bluxcc/core";
+import type {
+  GetBalancesOptions,
+  GetBalancesResult,
+} from "@bluxcc/core/dist/exports/core/getBalances";
+import { getAddress, getNetwork } from "../utils";
+
+export function useBalances(
+  options?: GetBalancesOptions,
+  queryOptions?: UseQueryOptions<GetBalancesResult, Error>
+): UseQueryResult<GetBalancesResult, Error> {
+
+  const address = getAddress(options?.address);
+  const network = getNetwork(options?.network);
+
+  const enabled = !!address && (queryOptions?.enabled ?? true);
+
+  const queryKey = useMemo(
+    () => [
+      "blux",
+      "balances",
+      address ?? null,
+      network ?? null,
+      Boolean(options?.includeZeroBalances),
+    ],
+    [address, network, options?.includeZeroBalances]
+  );
+
+  const queryFn = useMemo(
+    () => async () => {
+      const opts: GetBalancesOptions = {
+        address: options?.address,
+        network: options?.network,
+        includeZeroBalances: options?.includeZeroBalances,
+      };
+      return getBalances(opts);
+    },
+    [options?.address, options?.network, options?.includeZeroBalances]
+  );
+
+  const result = useQuery<GetBalancesResult, Error>({
+    queryKey,
+    queryFn,
+    enabled,
+    ...queryOptions,
+  });
+
+  return result;
+}
+
+export default useBalances;

src/useStellar/useClaimableBalances.ts

@@ -0,0 +1,60 @@
+// Gives "Issuer is invalid"
+
+import { useEffect, useState } from "react";
+import { getClaimableBalances } from "@bluxcc/core";
+
+import {
+  GetClaimableBalancesOptions,
+  GetClaimableBalancesResult,
+} from "@bluxcc/core/dist/exports/core/getClaimableBalances";
+
+export type UseClaimableBalancesResult = {
+  loading: boolean;
+  error: Error | null;
+  result: GetClaimableBalancesResult | null;
+};
+
+export function useClaimableBalances(
+  options: GetClaimableBalancesOptions
+): UseClaimableBalancesResult {
+  const [result, setResult] = useState<GetClaimableBalancesResult | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    setLoading(true);
+    setError(null);
+    setResult(null);
+
+    getClaimableBalances(options)
+      .then((r) => {
+        if (!cancelled) {
+          setResult(r);
+          setLoading(false);
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          setError(err);
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    options.network,
+    options.cursor,
+    options.limit,
+    options.order,
+
+    options.asset,
+    options.claimant,
+    options.sponsor,
+  ]);
+
+  return { loading, error, result };
+}

src/useStellar/useEffects.ts

@@ -0,0 +1,57 @@
+import { useEffect, useState } from "react";
+import { getEffects } from "@bluxcc/core";
+
+import {
+  GetEffectsOptions,
+  GetEffectsResult,
+} from "@bluxcc/core/dist/exports/core/getEffects";
+
+export type UseEffectsResult = {
+  loading: boolean;
+  error: Error | null;
+  result: GetEffectsResult | null;
+};
+
+export function useEffects(options: GetEffectsOptions): UseEffectsResult {
+  const [result, setResult] = useState<GetEffectsResult | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [loading, setLoading] = useState<boolean>(false);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    setLoading(true);
+    setError(null);
+    setResult(null);
+
+    getEffects(options)
+      .then((res) => {
+        if (!cancelled) {
+          setResult(res);
+          setLoading(false);
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          setError(err);
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [
+    options.network,
+    options.cursor,
+    options.limit,
+    options.order,
+    options.forAccount,
+    options.forLedger,
+    options.forTransaction,
+    options.forOperation,
+    options.forLiquidityPool,
+  ]);
+
+  return { loading, error, result };
+}

src/useStellar/useLedgers.ts

@@ -0,0 +1,47 @@
+import { useEffect, useState } from "react";
+import { getLedgers } from "@bluxcc/core";
+
+import {
+  GetLedgersOptions,
+  GetLedgersResult,
+} from "@bluxcc/core/dist/exports/core/getLedgers";
+
+export type UseLedgersResult = {
+  loading: boolean;
+  error: Error | null;
+  result: GetLedgersResult | null;
+};
+
+export function useLedgers(options: GetLedgersOptions): UseLedgersResult {
+  const [result, setResult] = useState<GetLedgersResult | null>(null);
+  const [error, setError] = useState<Error | null>(null);
+  const [loading, setLoading] = useState(false);
+
+  useEffect(() => {
+    let cancelled = false;
+
+    setLoading(true);
+    setError(null);
+    setResult(null);
+
+    getLedgers(options)
+      .then((r) => {
+        if (!cancelled) {
+          setResult(r);
+          setLoading(false);
+        }
+      })
+      .catch((err) => {
+        if (!cancelled) {
+          setError(err);
+          setLoading(false);
+        }
+      });
+
+    return () => {
+      cancelled = true;
+    };
+  }, [options.network, options.cursor, options.limit, options.order, options.ledger]);
+
+  return { loading, error, result };
+}