@sodax/dapp-kit 0.0.1-rc.1 → 0.0.1-rc.11

package/dist/hooks/swap/useSwapApprove.d.ts

@@ -0,0 +1,26 @@
+import type { Token } from '@sodax/types';
+import type { SpokeProvider } from '@sodax/sdk';
+interface UseApproveReturn {
+    approve: ({ amount }: {
+        amount: string;
+    }) => Promise<boolean>;
+    isLoading: boolean;
+    error: Error | null;
+    resetError: () => void;
+}
+/**
+ * Hook for approving token spending for money market actions
+ * @param token The token to approve spending for
+ * @param spokeProvider The spoke provider instance for the chain
+ * @returns Object containing approve function, loading state, error state and reset function
+ * @example
+ * ```tsx
+ * const { approve, isLoading, error } = useApprove(token, spokeProvider);
+ *
+ * // Approve tokens for supply action
+ * await approve({ amount: "100", action: "supply" });
+ * ```
+ */
+export declare function useSwapApprove(token: Token | undefined, spokeProvider: SpokeProvider | undefined): UseApproveReturn;
+export {};
+//# sourceMappingURL=useSwapApprove.d.ts.map

package/dist/hooks/swap/useSwapApprove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSwapApprove.d.ts","sourceRoot":"","sources":["../../../src/hooks/swap/useSwapApprove.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,UAAU,gBAAgB;IACxB,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9D,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,IAAI,CAAC;CACxB;AAED;;;;;;;;;;;;GAYG;AAEH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE,aAAa,EAAE,aAAa,GAAG,SAAS,GAAG,gBAAgB,CAwCnH"}

package/dist/index.js

@@ -1,11 +1,10 @@
 'use strict';
 
 var React = require('react');
-var reactQuery = require('@tanstack/react-query');
 var sdk = require('@sodax/sdk');
+var reactQuery = require('@tanstack/react-query');
 var walletSdk = require('@sodax/wallet-sdk');
 var viem = require('viem');
-var types = require('@sodax/types');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -20,111 +19,83 @@ var useSodaxContext = () => {
   }
   return context;
 };
-function useSpokeProvider(spokeChainId) {
+function useEstimateGas(spokeProvider) {
+  return reactQuery.useMutation({
+    mutationFn: async (rawTx) => {
+      if (!spokeProvider) {
+        throw new Error("spokeProvider is not found");
+      }
+      const response = await sdk.SpokeService.estimateGas(rawTx, spokeProvider);
+      return response;
+    }
+  });
+}
+
+// src/hooks/provider/useHubProvider.ts
+function useHubProvider() {
+  const { hubProvider } = useSodaxContext();
+  return hubProvider;
+}
+function useSpokeProvider(spokeChainId, walletProvider) {
   const xChainType = walletSdk.getXChainType(spokeChainId);
-  const walletProvider = walletSdk.useWalletProvider(spokeChainId);
+  const walletProvider_ = walletSdk.useWalletProvider(spokeChainId);
+  const _walletProvider = walletProvider ?? walletProvider_;
   const spokeProvider = React.useMemo(() => {
-    if (!walletProvider) return void 0;
+    if (!_walletProvider) return void 0;
+    if (!spokeChainId) return void 0;
     if (xChainType === "EVM") {
-      return new sdk.EvmSpokeProvider(walletProvider, sdk.spokeChainConfig[spokeChainId]);
+      return new sdk.EvmSpokeProvider(
+        _walletProvider,
+        sdk.spokeChainConfig[spokeChainId]
+      );
     }
     if (xChainType === "SUI") {
-      return new sdk.SuiSpokeProvider(sdk.spokeChainConfig[spokeChainId], walletProvider);
+      return new sdk.SuiSpokeProvider(
+        sdk.spokeChainConfig[spokeChainId],
+        _walletProvider
+      );
     }
-    return void 0;
-  }, [walletProvider, xChainType, spokeChainId]);
-  return spokeProvider;
-}
-function useAllowance(token, amount) {
-  const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(token.xChainId);
-  return reactQuery.useQuery({
-    queryKey: ["allowance", token.address, amount],
-    queryFn: async () => {
-      if (!spokeProvider) {
-        return false;
-      }
-      const allowance = await sodax.moneyMarket.isAllowanceValid(
-        {
-          token: token.address,
-          amount: viem.parseUnits(amount, token.decimals)
-        },
-        spokeProvider
+    if (xChainType === "ICON") {
+      return new sdk.IconSpokeProvider(
+        _walletProvider,
+        sdk.spokeChainConfig[spokeChainId]
       );
-      if (allowance.ok) {
-        return allowance.value;
-      }
-      return false;
-    },
-    enabled: !!spokeProvider
-  });
-}
-function useApprove(token) {
-  const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(token.xChainId);
-  const queryClient = reactQuery.useQueryClient();
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError
-  } = reactQuery.useMutation({
-    mutationFn: async (amount) => {
-      if (!spokeProvider) {
-        throw new Error("Spoke provider not found");
-      }
-      const allowance = await sodax.moneyMarket.approve(
-        token.address,
-        viem.parseUnits(amount, token.decimals),
-        spokeProvider.chainConfig.addresses.assetManager,
-        spokeProvider
+    }
+    if (xChainType === "INJECTIVE") {
+      return new sdk.InjectiveSpokeProvider(
+        sdk.spokeChainConfig[spokeChainId],
+        _walletProvider
       );
-      if (!allowance.ok) {
-        throw new Error("Failed to approve tokens");
-      }
-      return allowance.ok;
-    },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["allowance", token.address] });
     }
-  });
-  return {
-    approve,
-    isLoading: isPending,
-    error,
-    resetError
-  };
-}
-function useHubProvider() {
-  const { sodax } = useSodaxContext();
-  const hubChainId = sodax.config?.hubProviderConfig?.chainConfig.chain.id;
-  const hubRpcUrl = sodax.config?.hubProviderConfig?.hubRpcUrl;
-  const xChainType = walletSdk.getXChainType(hubChainId);
-  const hubProvider = React.useMemo(() => {
-    if (xChainType === "EVM" && hubChainId && hubRpcUrl) {
-      const hubChainCfg = sdk.getHubChainConfig(hubChainId);
-      if (!hubChainCfg) return void 0;
-      return new sdk.EvmHubProvider({
-        hubRpcUrl,
-        chainConfig: hubChainCfg
+    if (xChainType === "STELLAR") {
+      const stellarConfig = sdk.spokeChainConfig[spokeChainId];
+      return new sdk.StellarSpokeProvider(_walletProvider, stellarConfig, {
+        horizonRpcUrl: stellarConfig.horizonRpcUrl,
+        sorobanRpcUrl: stellarConfig.sorobanRpcUrl
       });
     }
+    if (xChainType === "SOLANA") {
+      return new sdk.SolanaSpokeProvider(
+        _walletProvider,
+        sdk.spokeChainConfig[spokeChainId]
+      );
+    }
     return void 0;
-  }, [xChainType, hubChainId, hubRpcUrl]);
-  return hubProvider;
+  }, [spokeChainId, xChainType, _walletProvider]);
+  return spokeProvider;
 }
-function useBorrow(hubToken, spokeChainId) {
+function useBorrow(spokeToken, spokeProvider) {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeChainId);
   return reactQuery.useMutation({
     mutationFn: async (amount) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.borrowAndSubmit(
+      const response = await sodax.moneyMarket.borrow(
         {
-          token: hubToken.address,
-          amount: viem.parseUnits(amount, hubToken.decimals)
+          token: spokeToken.address,
+          amount: viem.parseUnits(amount, 18),
+          action: "borrow"
         },
         spokeProvider
       );
@@ -136,18 +107,18 @@ function useBorrow(hubToken, spokeChainId) {
     }
   });
 }
-function useRepay(hubToken, spokeChainId) {
+function useRepay(spokeToken, spokeProvider) {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeChainId);
   return reactQuery.useMutation({
     mutationFn: async (amount) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.repayAndSubmit(
+      const response = await sodax.moneyMarket.repay(
         {
-          token: hubToken.address,
-          amount: viem.parseUnits(amount, hubToken.decimals)
+          token: spokeToken.address,
+          amount: viem.parseUnits(amount, spokeToken.decimals),
+          action: "repay"
         },
         spokeProvider
       );
@@ -159,18 +130,18 @@ function useRepay(hubToken, spokeChainId) {
     }
   });
 }
-function useSupply(spokeToken) {
+function useSupply(spokeToken, spokeProvider) {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeToken.xChainId);
   return reactQuery.useMutation({
     mutationFn: async (amount) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.supplyAndSubmit(
+      const response = await sodax.moneyMarket.supply(
         {
           token: spokeToken.address,
-          amount: viem.parseUnits(amount, spokeToken.decimals)
+          amount: viem.parseUnits(amount, spokeToken.decimals),
+          action: "supply"
         },
         spokeProvider
       );
@@ -182,18 +153,19 @@ function useSupply(spokeToken) {
     }
   });
 }
-function useWithdraw(hubToken, spokeChainId) {
+function useWithdraw(spokeToken, spokeProvider) {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(spokeChainId);
   return reactQuery.useMutation({
     mutationFn: async (amount) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.withdrawAndSubmit(
+      const response = await sodax.moneyMarket.withdraw(
         {
-          token: hubToken.address,
-          amount: viem.parseUnits(amount, hubToken.decimals)
+          token: spokeToken.address,
+          // vault token on hub chain decimals is 18
+          amount: viem.parseUnits(amount, 18),
+          action: "withdraw"
         },
         spokeProvider
       );
@@ -205,100 +177,107 @@ function useWithdraw(hubToken, spokeChainId) {
     }
   });
 }
-var allXTokens = [];
-Object.keys(sdk.hubAssets).forEach((xChainId) => {
-  const tokens = sdk.hubAssets[xChainId];
-  Object.keys(tokens).forEach((tokenAddress) => {
-    const token = tokens[tokenAddress];
-    allXTokens.push({
-      xChainId,
-      symbol: token.symbol,
-      name: token.name,
-      decimals: token.decimal,
-      address: tokenAddress
-    });
-    allXTokens.push({
-      // @ts-ignore
-      xChainId: types.CHAIN_IDS.includes(xChainId) ? "sonic" : "sonic-blaze",
-      symbol: token.symbol,
-      name: token.name,
-      decimals: token.decimal,
-      address: token.vault
-    });
-  });
-});
-var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
-  const tokens = sdk.hubAssets[spokeChainId];
-  const token = Object.keys(tokens).find((tokenAddress) => tokens[tokenAddress].vault === vault);
-  if (!token) {
-    throw new Error("Token not found");
-  }
-  return token;
-};
-function useHubWalletAddress(spokeChainId, address, hubProvider) {
-  return reactQuery.useQuery({
-    queryKey: ["hubWallet", spokeChainId, address],
+function useUserReservesData(spokeChainId, address) {
+  const { sodax } = useSodaxContext();
+  const hubChainId = sodax.config?.hubProviderConfig?.chainConfig.chain.id ?? "sonic";
+  const hubProvider = useHubProvider();
+  const { data: userReserves } = reactQuery.useQuery({
+    queryKey: ["userReserves", spokeChainId, address],
     queryFn: async () => {
-      if (!address) return null;
-      try {
-        const hubWalletAddress = await sdk.EvmWalletAbstraction.getUserHubWalletAddress(
-          spokeChainId,
-          address,
-          hubProvider
-        );
-        return hubWalletAddress;
-      } catch (error) {
-        console.log("error", error);
-        return null;
+      if (!hubProvider || !address) {
+        return;
       }
+      const addressBytes = sdk.encodeAddress(spokeChainId, address);
+      const hubWalletAddress = await sdk.EvmWalletAbstraction.getUserHubWalletAddress(
+        spokeChainId,
+        addressBytes,
+        hubProvider
+      );
+      const moneyMarketConfig = sdk.getMoneyMarketConfig(hubChainId);
+      const [res] = await sodax.moneyMarket.getUserReservesData(
+        hubWalletAddress,
+        moneyMarketConfig.uiPoolDataProvider,
+        moneyMarketConfig.poolAddressesProvider
+      );
+      return res;
     },
-    enabled: !!address && !!hubProvider
+    enabled: !!spokeChainId && !!hubProvider && !!address,
+    refetchInterval: 5e3
   });
+  return userReserves;
 }
-
-// src/hooks/mm/useUserReservesData.ts
-function useUserReservesData(spokeChainId) {
+function useReservesData() {
   const { sodax } = useSodaxContext();
   const hubChainId = sodax.config?.hubProviderConfig?.chainConfig.chain.id ?? "sonic";
-  const hubWalletProvider = walletSdk.useWalletProvider(hubChainId);
-  const hubProvider = useHubProvider();
-  const { address } = walletSdk.useXAccount(spokeChainId);
-  const { data: hubWalletAddress } = useHubWalletAddress(
-    spokeChainId,
-    address,
-    hubProvider
-  );
-  const { data: userReserves } = reactQuery.useQuery({
-    queryKey: ["userReserves", hubWalletAddress],
+  return reactQuery.useQuery({
+    queryKey: ["reservesData"],
     queryFn: async () => {
-      if (!hubWalletProvider) {
-        return;
+      const moneyMarketConfig = sdk.getMoneyMarketConfig(hubChainId);
+      return await sodax.moneyMarket.getReservesData(
+        moneyMarketConfig.uiPoolDataProvider,
+        moneyMarketConfig.poolAddressesProvider
+      );
+    }
+  });
+}
+function useMMAllowance(token, amount, action, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["allowance", token.address, amount, action],
+    queryFn: async () => {
+      if (!spokeProvider) throw new Error("Spoke provider is required");
+      const allowance = await sodax.moneyMarket.isAllowanceValid(
+        {
+          token: token.address,
+          amount: viem.parseUnits(amount, token.decimals),
+          action
+        },
+        spokeProvider
+      );
+      if (allowance.ok) {
+        return allowance.value;
       }
-      if (!hubWalletAddress) {
-        return;
+      return false;
+    },
+    enabled: !!spokeProvider
+  });
+}
+function useMMApprove(token, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  const queryClient = reactQuery.useQueryClient();
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError
+  } = reactQuery.useMutation({
+    mutationFn: async ({ amount, action }) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
       }
-      const moneyMarketConfig = sdk.getMoneyMarketConfig(hubChainId);
-      try {
-        const [res] = await sodax.moneyMarket.getUserReservesData(
-          hubWalletAddress,
-          moneyMarketConfig.uiPoolDataProvider,
-          moneyMarketConfig.poolAddressesProvider
-        );
-        return res?.map((r) => {
-          return {
-            ...r,
-            token: allXTokens.find((t) => t.address === r.underlyingAsset)
-          };
-        });
-      } catch (error) {
-        console.log("error", error);
-        return;
+      const allowance = await sodax.moneyMarket.approve(
+        {
+          token: token.address,
+          amount: viem.parseUnits(amount, token.decimals),
+          action
+        },
+        spokeProvider
+      );
+      if (!allowance.ok) {
+        throw new Error("Failed to approve tokens");
       }
+      return allowance.ok;
     },
-    enabled: !!address && !!hubWalletProvider && !!hubWalletAddress,
-    refetchInterval: 5e3
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["allowance", token.address] });
+    }
   });
-  return userReserves;
+  return {
+    approve,
+    isLoading: isPending,
+    error,
+    resetError
+  };
 }
 var useQuote = (payload) => {
   const { sodax } = useSodaxContext();
@@ -314,9 +293,8 @@ var useQuote = (payload) => {
     refetchInterval: 3e3
   });
 };
-function useCreateIntentOrder(chainId) {
+function useCreateIntentOrder(spokeProvider) {
   const { sodax } = useSodaxContext();
-  const spokeProvider = useSpokeProvider(chainId);
   return reactQuery.useMutation({
     mutationFn: async (params) => {
       if (!spokeProvider) {
@@ -337,26 +315,101 @@ var useStatus = (intent_tx_hash) => {
     // 3s
   });
 };
+function useSwapAllowance(params, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useQuery({
+    queryKey: ["allowance", params],
+    queryFn: async () => {
+      if (!spokeProvider || !params) {
+        return false;
+      }
+      const allowance = await sodax.solver.isAllowanceValid(params, spokeProvider);
+      if (allowance.ok) {
+        return allowance.value;
+      }
+      return false;
+    },
+    enabled: !!spokeProvider && !!params
+  });
+}
+function useSwapApprove(token, spokeProvider) {
+  const { sodax } = useSodaxContext();
+  const queryClient = reactQuery.useQueryClient();
+  const {
+    mutateAsync: approve,
+    isPending,
+    error,
+    reset: resetError
+  } = reactQuery.useMutation({
+    mutationFn: async ({ amount }) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      if (!token) {
+        throw new Error("Token not found");
+      }
+      const allowance = await sodax.solver.approve(
+        token.address,
+        viem.parseUnits(amount, token.decimals),
+        spokeProvider
+      );
+      if (!allowance.ok) {
+        throw new Error("Failed to approve tokens");
+      }
+      return allowance.ok;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["allowance", token?.address] });
+    }
+  });
+  return {
+    approve,
+    isLoading: isPending,
+    error,
+    resetError
+  };
+}
 var SodaxProvider = ({ children, testnet = false, config }) => {
   const sodax = new sdk.Sodax(config);
-  return /* @__PURE__ */ React__default.default.createElement(SodaxContext.Provider, { value: { sodax, testnet } }, children);
+  const hubChainId = config?.hubProviderConfig?.chainConfig.chain.id;
+  const hubRpcUrl = config?.hubProviderConfig?.hubRpcUrl;
+  const hubProvider = React.useMemo(() => {
+    if (hubChainId && hubRpcUrl) {
+      const hubChainCfg = sdk.getHubChainConfig(hubChainId);
+      return new sdk.EvmHubProvider({
+        hubRpcUrl,
+        chainConfig: hubChainCfg
+      });
+    }
+    return void 0;
+  }, [hubChainId, hubRpcUrl]);
+  return /* @__PURE__ */ React__default.default.createElement(SodaxContext.Provider, { value: { sodax, testnet, hubProvider } }, children);
+};
+var getSpokeTokenAddressByVault = (spokeChainId, vault) => {
+  const tokens = sdk.hubAssets[spokeChainId];
+  const address = Object.keys(tokens).find(
+    (tokenAddress) => tokens[tokenAddress].vault.toLowerCase() === vault.toLowerCase()
+  );
+  return address;
 };
 
 exports.SodaxProvider = SodaxProvider;
-exports.allXTokens = allXTokens;
 exports.getSpokeTokenAddressByVault = getSpokeTokenAddressByVault;
-exports.useAllowance = useAllowance;
-exports.useApprove = useApprove;
 exports.useBorrow = useBorrow;
 exports.useCreateIntentOrder = useCreateIntentOrder;
+exports.useEstimateGas = useEstimateGas;
 exports.useHubProvider = useHubProvider;
-exports.useHubWalletAddress = useHubWalletAddress;
+exports.useMMAllowance = useMMAllowance;
+exports.useMMApprove = useMMApprove;
 exports.useQuote = useQuote;
 exports.useRepay = useRepay;
+exports.useReservesData = useReservesData;
 exports.useSodaxContext = useSodaxContext;
 exports.useSpokeProvider = useSpokeProvider;
 exports.useStatus = useStatus;
 exports.useSupply = useSupply;
+exports.useSwapAllowance = useSwapAllowance;
+exports.useSwapApprove = useSwapApprove;
 exports.useUserReservesData = useUserReservesData;
 exports.useWithdraw = useWithdraw;
 //# sourceMappingURL=index.js.map