@sodax/dapp-kit 1.0.1-beta → 1.0.3-beta

package/dist/index.js

@@ -181,218 +181,275 @@ function useSpokeProvider(spokeChainId, walletProvider) {
   }, [spokeChainId, xChainType, walletProvider, rpcConfig]);
   return spokeProvider;
 }
-function useBorrow(spokeToken, spokeProvider) {
+function useBorrow() {
   const { sodax } = useSodaxContext();
   return reactQuery.useMutation({
-    mutationFn: async (amount, toChainId, toAddress) => {
+    mutationFn: async ({ params, spokeProvider }) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.borrow(
-        {
-          token: spokeToken.address,
-          amount: viem.parseUnits(amount, 18),
-          action: "borrow",
-          toChainId,
-          toAddress
-        },
-        spokeProvider
-      );
+      const response = await sodax.moneyMarket.borrow(params, spokeProvider);
       if (!response.ok) {
-        throw new Error("Failed to borrow tokens");
+        throw response.error;
       }
-      console.log("Borrow transaction submitted:", response);
       return response;
     }
   });
 }
-function useRepay(spokeToken, spokeProvider) {
+function useRepay() {
   const { sodax } = useSodaxContext();
   return reactQuery.useMutation({
-    mutationFn: async (amount, toChainId, toAddress) => {
+    mutationFn: async ({ params, spokeProvider }) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.repay(
-        {
-          token: spokeToken.address,
-          amount: viem.parseUnits(amount, spokeToken.decimals),
-          action: "repay",
-          toChainId,
-          toAddress
-        },
-        spokeProvider
-      );
+      const response = await sodax.moneyMarket.repay(params, spokeProvider);
       if (!response.ok) {
-        throw new Error("Failed to repay tokens");
+        throw response.error;
       }
-      console.log("Repay transaction submitted:", response);
       return response;
     }
   });
 }
-function useSupply(spokeToken, spokeProvider) {
+function useSupply() {
   const { sodax } = useSodaxContext();
   return reactQuery.useMutation({
-    mutationFn: async (amount, toChainId, toAddress) => {
+    mutationFn: async ({ params, spokeProvider }) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.supply(
-        {
-          token: spokeToken.address,
-          amount: viem.parseUnits(amount, spokeToken.decimals),
-          action: "supply",
-          toChainId,
-          toAddress
-        },
-        spokeProvider
-      );
+      const response = await sodax.moneyMarket.supply(params, spokeProvider);
       if (!response.ok) {
-        throw new Error("Failed to supply tokens");
+        throw response.error;
       }
-      console.log("Supply transaction submitted:", response);
       return response;
     }
   });
 }
-function useWithdraw(spokeToken, spokeProvider) {
+function useWithdraw() {
   const { sodax } = useSodaxContext();
   return reactQuery.useMutation({
-    mutationFn: async (amount, toChainId, toAddress) => {
+    mutationFn: async ({ params, spokeProvider }) => {
       if (!spokeProvider) {
         throw new Error("spokeProvider is not found");
       }
-      const response = await sodax.moneyMarket.withdraw(
-        {
-          token: spokeToken.address,
-          // vault token on hub chain decimals is 18
-          amount: viem.parseUnits(amount, 18),
-          action: "withdraw",
-          toChainId,
-          toAddress
-        },
-        spokeProvider
-      );
+      const response = await sodax.moneyMarket.withdraw(params, spokeProvider);
       if (!response.ok) {
-        throw new Error("Failed to withdraw tokens");
+        throw response.error;
       }
-      console.log("Withdraw transaction submitted:", response);
       return response;
     }
   });
 }
-function useUserReservesData(spokeProvider, address, refetchInterval = 5e3) {
+function useUserReservesData(params) {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["mm", "userReservesData", params?.spokeProvider?.chainConfig.chain.id, params?.address],
+    enabled: !!params?.spokeProvider && !!params?.address,
+    refetchInterval: 5e3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+    // override default query options if provided
+  };
   return reactQuery.useQuery({
-    queryKey: ["userReserves", spokeProvider?.chainConfig.chain.id, address],
+    ...queryOptions,
     queryFn: async () => {
-      if (!spokeProvider) {
+      if (!params?.spokeProvider || !params?.address) {
         throw new Error("Spoke provider or address is not defined");
       }
-      return await sodax.moneyMarket.data.getUserReservesData(spokeProvider);
-    },
-    enabled: !!spokeProvider && !!address,
-    refetchInterval
+      return await sodax.moneyMarket.data.getUserReservesData(params.spokeProvider);
+    }
   });
 }
-function useReservesData() {
+function useReservesData(params) {
+  const defaultQueryOptions = {
+    queryKey: ["mm", "reservesData"],
+    refetchInterval: 5e3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+    // override default query options if provided
+  };
   const { sodax } = useSodaxContext();
   return reactQuery.useQuery({
-    queryKey: ["reservesData"],
+    ...queryOptions,
     queryFn: async () => {
       return await sodax.moneyMarket.data.getReservesData();
     }
   });
 }
-function useMMAllowance(token, amount, action, spokeProvider) {
+function useMMAllowance({
+  params,
+  spokeProvider,
+  queryOptions
+}) {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["mm", "allowance", params?.token, params?.action],
+    enabled: !!spokeProvider,
+    refetchInterval: 5e3
+  };
+  queryOptions = {
+    ...defaultQueryOptions,
+    ...queryOptions
+    // override default query options if provided
+  };
   return reactQuery.useQuery({
-    queryKey: ["allowance", token.address, amount, action],
+    ...queryOptions,
     queryFn: async () => {
       if (!spokeProvider) throw new Error("Spoke provider is required");
-      const actionBasedDecimals = action === "withdraw" || action === "borrow" ? 18 : token.decimals;
-      const allowance = await sodax.moneyMarket.isAllowanceValid(
-        {
-          token: token.address,
-          amount: viem.parseUnits(amount, actionBasedDecimals),
-          action
-        },
-        spokeProvider
-      );
-      if (allowance.ok) {
-        return allowance.value;
+      if (!params) throw new Error("Params are required");
+      const allowance = await sodax.moneyMarket.isAllowanceValid(params, spokeProvider);
+      if (!allowance.ok) {
+        throw allowance.error;
       }
-      return false;
-    },
-    enabled: !!spokeProvider
+      return allowance.value;
+    }
   });
 }
-function useMMApprove(token, spokeProvider) {
+function useMMApprove() {
   const { sodax } = useSodaxContext();
   const queryClient = reactQuery.useQueryClient();
-  const {
-    mutateAsync: approve,
-    isPending,
-    error,
-    reset: resetError
-  } = reactQuery.useMutation({
-    mutationFn: async ({ amount, action }) => {
+  return reactQuery.useMutation({
+    mutationFn: async ({ params, spokeProvider }) => {
       if (!spokeProvider) {
         throw new Error("Spoke provider not found");
       }
-      const actionBasedDecimals = action === "withdraw" || action === "borrow" ? 18 : token.decimals;
-      const allowance = await sodax.moneyMarket.approve(
-        {
-          token: token.address,
-          amount: viem.parseUnits(amount, actionBasedDecimals),
-          action
-        },
-        spokeProvider
-      );
+      const allowance = await sodax.moneyMarket.approve(params, spokeProvider, false);
       if (!allowance.ok) {
-        throw new Error("Failed to approve tokens");
+        throw allowance.error;
       }
-      return allowance.ok;
+      return allowance.value;
     },
-    onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["allowance", token.address] });
+    onSuccess: (_, { params, spokeProvider }) => {
+      console.log("onSuccess invoked with queryKey:", [
+        "mm",
+        "allowance",
+        spokeProvider?.chainConfig.chain.id,
+        params.token,
+        params.action
+      ]);
+      queryClient.invalidateQueries({
+        queryKey: ["mm", "allowance", spokeProvider?.chainConfig.chain.id, params.token, params.action]
+      });
     }
   });
-  return {
-    approve,
-    isLoading: isPending,
-    error,
-    resetError
-  };
 }
-function useAToken(aToken) {
+function useAToken({ aToken, queryOptions }) {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["mm", "aToken", aToken],
+    enabled: !!aToken
+  };
+  queryOptions = {
+    ...defaultQueryOptions,
+    ...queryOptions
+    // override default query options if provided
+  };
   return reactQuery.useQuery({
-    queryKey: ["aToken", sodax.hubProvider.chainConfig.chain.id, aToken],
+    ...queryOptions,
     queryFn: async () => {
       if (!aToken) {
         throw new Error("aToken address or hub provider is not defined");
       }
+      if (!viem.isAddress(aToken)) {
+        throw new Error("aToken address is not a valid address");
+      }
       const aTokenData = await sodax.moneyMarket.data.getATokenData(aToken);
       return {
         ...aTokenData,
         xChainId: sodax.hubProvider.chainConfig.chain.id
       };
-    },
-    enabled: !!aToken
+    }
+  });
+}
+function useATokensBalances({
+  aTokens,
+  spokeProvider,
+  userAddress,
+  queryOptions
+}) {
+  const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["mm", "aTokensBalances", aTokens, spokeProvider?.chainConfig.chain.id, userAddress],
+    enabled: aTokens.length > 0 && aTokens.every((token) => viem.isAddress(token)) && !!spokeProvider && !!userAddress
+  };
+  queryOptions = {
+    ...defaultQueryOptions,
+    ...queryOptions
+    // override default query options if provided
+  };
+  return reactQuery.useQuery({
+    ...queryOptions,
+    queryFn: async () => {
+      if (aTokens.length === 0) {
+        return /* @__PURE__ */ new Map();
+      }
+      if (!spokeProvider || !userAddress) {
+        throw new Error("Spoke provider and user address are required");
+      }
+      for (const aToken of aTokens) {
+        if (!viem.isAddress(aToken)) {
+          throw new Error(`Invalid aToken address: ${aToken}`);
+        }
+      }
+      const hubWalletAddress = await sdk.deriveUserWalletAddress(
+        sodax.hubProvider,
+        spokeProvider.chainConfig.chain.id,
+        userAddress
+      );
+      return await sodax.moneyMarket.data.getATokensBalances(aTokens, hubWalletAddress);
+    }
   });
 }
-function useReservesUsdFormat() {
+function useReservesUsdFormat(params) {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = { queryKey: ["mm", "reservesUsdFormat"] };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+    // override default query options if provided
+  };
   return reactQuery.useQuery({
-    queryKey: ["reservesUsdFormat"],
+    ...queryOptions,
     queryFn: async () => {
       const reserves = await sodax.moneyMarket.data.getReservesHumanized();
       return sodax.moneyMarket.data.formatReservesUSD(sodax.moneyMarket.data.buildReserveDataWithPrice(reserves));
     }
   });
 }
+function useUserFormattedSummary(params) {
+  const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["mm", "userFormattedSummary", params?.spokeProvider?.chainConfig.chain.id, params?.address],
+    enabled: !!params?.spokeProvider && !!params?.address,
+    refetchInterval: 5e3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+    // override default query options if provided
+  };
+  return reactQuery.useQuery({
+    ...queryOptions,
+    queryFn: async () => {
+      if (!params?.spokeProvider || !params?.address) {
+        throw new Error("Spoke provider or address is not defined");
+      }
+      const reserves = await sodax.moneyMarket.data.getReservesHumanized();
+      const formattedReserves = sodax.moneyMarket.data.formatReservesUSD(
+        sodax.moneyMarket.data.buildReserveDataWithPrice(reserves)
+      );
+      const userReserves = await sodax.moneyMarket.data.getUserReservesHumanized(params?.spokeProvider);
+      return sodax.moneyMarket.data.formatUserSummary(
+        sodax.moneyMarket.data.buildUserSummaryRequest(reserves, formattedReserves, userReserves)
+      );
+    }
+  });
+}
 var useQuote = (payload) => {
   const { sodax } = useSodaxContext();
   const queryKey = React.useMemo(() => {
@@ -514,135 +571,254 @@ function useCancelSwap(spokeProvider) {
     }
   });
 }
-var useBackendIntentByTxHash = (txHash, refetchInterval = 1e3) => {
+function useCreateLimitOrder(spokeProvider) {
   const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async (params) => {
+      if (!spokeProvider) {
+        throw new Error("Spoke provider not found");
+      }
+      return sodax.swaps.createLimitOrder({
+        intentParams: params,
+        spokeProvider
+      });
+    }
+  });
+}
+function useCancelLimitOrder() {
+  const { sodax } = useSodaxContext();
+  return reactQuery.useMutation({
+    mutationFn: async ({ intent, spokeProvider, timeout }) => {
+      return sodax.swaps.cancelLimitOrder({
+        intent,
+        spokeProvider,
+        timeout
+      });
+    }
+  });
+}
+var useBackendIntentByTxHash = (params) => {
+  const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "intent", "txHash", params?.params?.txHash],
+    enabled: !!params?.params?.txHash && params?.params?.txHash.length > 0,
+    retry: 3,
+    refetchInterval: 1e3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "intent", "txHash", txHash],
+    ...queryOptions,
     queryFn: async () => {
-      if (!txHash) {
+      if (!params?.params?.txHash) {
         return void 0;
       }
-      return sodax.backendApi.getIntentByTxHash(txHash);
-    },
-    refetchInterval,
-    enabled: !!txHash && txHash.length > 0,
-    retry: 3
+      return sodax.backendApi.getIntentByTxHash(params.params.txHash);
+    }
   });
 };
-var useBackendIntentByHash = (intentHash) => {
+var useBackendIntentByHash = (params) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "intent", "hash", params?.params?.intentHash],
+    enabled: !!params?.params?.intentHash && params?.params?.intentHash.length > 0,
+    retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "intent", "hash", intentHash],
+    ...queryOptions,
     queryFn: async () => {
-      if (!intentHash) {
+      if (!params?.params?.intentHash) {
         return void 0;
       }
-      return sodax.backendApi.getIntentByHash(intentHash);
-    },
-    enabled: !!intentHash && intentHash.length > 0,
-    retry: 3
+      return sodax.backendApi.getIntentByHash(params.params.intentHash);
+    }
   });
 };
-var useBackendOrderbook = (params) => {
+var useBackendUserIntents = ({
+  params,
+  queryOptions
+}) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "intent", "user", params],
+    enabled: !!params && !!params.userAddress && params.userAddress.length > 0,
+    retry: 3
+  };
+  queryOptions = {
+    ...defaultQueryOptions,
+    ...queryOptions
+    // override default query options if provided
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "solver", "orderbook", params],
+    ...queryOptions,
     queryFn: async () => {
-      if (!params || !params.offset || !params.limit) {
+      if (!params?.userAddress) {
         return void 0;
       }
-      return sodax.backendApi.getOrderbook(params);
-    },
-    enabled: !!params && !!params.offset && !!params.limit,
+      return sodax.backendApi.getUserIntents(params);
+    }
+  });
+};
+var useBackendOrderbook = (params) => {
+  const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "solver", "orderbook", params?.pagination?.offset, params?.pagination?.limit],
+    enabled: !!params?.pagination && !!params?.pagination.offset && !!params?.pagination.limit,
     staleTime: 30 * 1e3,
     // 30 seconds for real-time data
     retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+    // override default query options if provided
+  };
+  return reactQuery.useQuery({
+    ...queryOptions,
+    queryFn: async () => {
+      if (!params?.pagination || !params?.pagination.offset || !params?.pagination.limit) {
+        return void 0;
+      }
+      return sodax.backendApi.getOrderbook(params.pagination);
+    }
   });
 };
-var useBackendMoneyMarketPosition = (userAddress) => {
+var useBackendMoneyMarketPosition = (params) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "mm", "position", params?.userAddress],
+    enabled: !!params?.userAddress && params?.userAddress.length > 0,
+    retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "moneymarket", "position", userAddress],
+    ...queryOptions,
     queryFn: async () => {
-      if (!userAddress) {
+      if (!params?.userAddress) {
         return void 0;
       }
-      return sodax.backendApi.getMoneyMarketPosition(userAddress);
-    },
-    enabled: !!userAddress && userAddress.length > 0,
-    retry: 3
+      return sodax.backendApi.getMoneyMarketPosition(params.userAddress);
+    }
   });
 };
-var useBackendAllMoneyMarketAssets = () => {
+var useBackendAllMoneyMarketAssets = (params) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "mm", "assets", "all"],
+    enabled: true,
+    retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "moneymarket", "assets", "all"],
+    ...queryOptions,
     queryFn: async () => {
       return sodax.backendApi.getAllMoneyMarketAssets();
-    },
-    retry: 3
+    }
   });
 };
-var useBackendMoneyMarketAsset = (reserveAddress) => {
+var useBackendMoneyMarketAsset = (params) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "mm", "asset", params?.params?.reserveAddress],
+    enabled: !!params?.params?.reserveAddress && params?.params?.reserveAddress.length > 0,
+    retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "moneymarket", "asset", reserveAddress],
+    ...queryOptions,
     queryFn: async () => {
-      if (!reserveAddress) {
+      if (!params?.params?.reserveAddress) {
         return void 0;
       }
-      return sodax.backendApi.getMoneyMarketAsset(reserveAddress);
-    },
-    enabled: !!reserveAddress && reserveAddress.length > 0,
-    retry: 3
+      return sodax.backendApi.getMoneyMarketAsset(params.params.reserveAddress);
+    }
   });
 };
 var useBackendMoneyMarketAssetBorrowers = (params) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "mm", "asset", "borrowers", params],
+    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
+    retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "moneymarket", "asset", "borrowers", params],
+    ...queryOptions,
     queryFn: async () => {
-      if (!params.reserveAddress || !params.offset || !params.limit) {
+      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
         return void 0;
       }
-      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.reserveAddress, {
-        offset: params.offset,
-        limit: params.limit
+      return sodax.backendApi.getMoneyMarketAssetBorrowers(params.params.reserveAddress, {
+        offset: params.pagination.offset,
+        limit: params.pagination.limit
       });
-    },
-    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
-    retry: 3
+    }
   });
 };
 var useBackendMoneyMarketAssetSuppliers = (params) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "mm", "asset", "suppliers", params],
+    enabled: !!params?.params?.reserveAddress && !!params.pagination.offset && !!params.pagination.limit,
+    retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "moneymarket", "asset", "suppliers", params],
+    ...queryOptions,
     queryFn: async () => {
-      if (!params.reserveAddress || !params.offset || !params.limit) {
+      if (!params?.params?.reserveAddress || !params.pagination.offset || !params.pagination.limit) {
         return void 0;
       }
-      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.reserveAddress, {
-        offset: params.offset,
-        limit: params.limit
+      return sodax.backendApi.getMoneyMarketAssetSuppliers(params.params.reserveAddress, {
+        offset: params.pagination.offset,
+        limit: params.pagination.limit
       });
-    },
-    enabled: !!params.reserveAddress && !!params.offset && !!params.limit,
-    retry: 3
+    }
   });
 };
 var useBackendAllMoneyMarketBorrowers = (params) => {
   const { sodax } = useSodaxContext();
+  const defaultQueryOptions = {
+    queryKey: ["api", "mm", "borrowers", "all", params],
+    enabled: !!params && !!params.pagination.offset && !!params.pagination.limit,
+    retry: 3
+  };
+  const queryOptions = {
+    ...defaultQueryOptions,
+    ...params?.queryOptions
+  };
   return reactQuery.useQuery({
-    queryKey: ["backend", "moneymarket", "borrowers", "all", params],
+    ...queryOptions,
     queryFn: async () => {
-      if (!params || !params.offset || !params.limit) {
+      if (!params || !params.pagination.offset || !params.pagination.limit) {
         return void 0;
       }
-      return sodax.backendApi.getAllMoneyMarketBorrowers(params);
-    },
-    enabled: !!params && !!params.offset && !!params.limit,
-    retry: 3
+      return sodax.backendApi.getAllMoneyMarketBorrowers({
+        offset: params.pagination.offset,
+        limit: params.pagination.limit
+      });
+    }
   });
 };
 function useBridgeAllowance(params, spokeProvider) {
@@ -1289,6 +1465,7 @@ exports.MIGRATION_MODE_BNUSD = MIGRATION_MODE_BNUSD;
 exports.MIGRATION_MODE_ICX_SODA = MIGRATION_MODE_ICX_SODA;
 exports.SodaxProvider = SodaxProvider;
 exports.useAToken = useAToken;
+exports.useATokensBalances = useATokensBalances;
 exports.useBackendAllMoneyMarketAssets = useBackendAllMoneyMarketAssets;
 exports.useBackendAllMoneyMarketBorrowers = useBackendAllMoneyMarketBorrowers;
 exports.useBackendIntentByHash = useBackendIntentByHash;
@@ -1298,14 +1475,17 @@ exports.useBackendMoneyMarketAssetBorrowers = useBackendMoneyMarketAssetBorrower
 exports.useBackendMoneyMarketAssetSuppliers = useBackendMoneyMarketAssetSuppliers;
 exports.useBackendMoneyMarketPosition = useBackendMoneyMarketPosition;
 exports.useBackendOrderbook = useBackendOrderbook;
+exports.useBackendUserIntents = useBackendUserIntents;
 exports.useBorrow = useBorrow;
 exports.useBridge = useBridge;
 exports.useBridgeAllowance = useBridgeAllowance;
 exports.useBridgeApprove = useBridgeApprove;
+exports.useCancelLimitOrder = useCancelLimitOrder;
 exports.useCancelSwap = useCancelSwap;
 exports.useCancelUnstake = useCancelUnstake;
 exports.useClaim = useClaim;
 exports.useConvertedAssets = useConvertedAssets;
+exports.useCreateLimitOrder = useCreateLimitOrder;
 exports.useDeriveUserWalletAddress = useDeriveUserWalletAddress;
 exports.useEstimateGas = useEstimateGas;
 exports.useGetBridgeableAmount = useGetBridgeableAmount;
@@ -1344,6 +1524,7 @@ exports.useUnstakeAllowance = useUnstakeAllowance;
 exports.useUnstakeApprove = useUnstakeApprove;
 exports.useUnstakingInfo = useUnstakingInfo;
 exports.useUnstakingInfoWithPenalty = useUnstakingInfoWithPenalty;
+exports.useUserFormattedSummary = useUserFormattedSummary;
 exports.useUserReservesData = useUserReservesData;
 exports.useWithdraw = useWithdraw;
 //# sourceMappingURL=index.js.map