@velora-dex/widget 0.5.1-dev.1 → 0.6.0

package/dist/hooks/txs/queries/useTxResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTxResponse.d.ts","sourceRoot":"","sources":["../../../../src/hooks/txs/queries/useTxResponse.ts"],"names":[],"mappings":"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAD5oW"}

package/dist/hooks/txs/queries/useTxResponse.js

@@ -0,0 +1,31 @@
+import { ensureTxResponseFactory as e } from "../../../transactions/queries/ensureTxResponse.js";
+import { c as t } from "react-compiler-runtime";
+import { useQueryClient as n } from "@tanstack/react-query";
+import { useConfig as r, useTransaction as i } from "wagmi";
+//#region src/hooks/txs/queries/useTxResponse.ts
+function a() {
+	let i = t(3), a = n(), o = r(), s;
+	return i[0] !== a || i[1] !== o ? (s = e({
+		queryClient: a,
+		wagmiConfig: o
+	}), i[0] = a, i[1] = o, i[2] = s) : s = i[2], s;
+}
+function o(e) {
+	let n = t(9), { hash: r, chainId: o, enabled: s } = e, c = s === void 0 ? !0 : s, l = a(), u = !!r && c, d;
+	n[0] === u ? d = n[1] : (d = { enabled: u }, n[0] = u, n[1] = d);
+	let f;
+	n[2] !== o || n[3] !== r || n[4] !== d ? (f = {
+		hash: r,
+		chainId: o,
+		query: d
+	}, n[2] = o, n[3] = r, n[4] = d, n[5] = f) : f = n[5];
+	let p = i(f), m;
+	return n[6] !== l || n[7] !== p ? (m = {
+		query: p,
+		ensureTxResponse: l
+	}, n[6] = l, n[7] = p, n[8] = m) : m = n[8], m;
+}
+//#endregion
+export { o as useTxResponse };
+
+//# sourceMappingURL=useTxResponse.js.map

package/dist/hooks/txs/queries/useTxResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTxResponse.js","names":["SupportedChainId","ensureTxResponseFactory","EnsureTxResponseFn","useQueryClient","Hash","useConfig","useTransaction","useEnsureTxResponse","$","_c","queryClient","wagmiConfig","t0","UseTxResponseInput","hash","chainId","enabled","useTxResponse","t1","undefined","ensureTxResponse","t2","t3","t4","query","txResponseQuery","t5"],"sources":["../../../../src/hooks/txs/queries/useTxResponse.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport {\n  ensureTxResponseFactory,\n  type EnsureTxResponseFn,\n} from \"@/transactions/queries/ensureTxResponse\";\nimport { useQueryClient } from \"@tanstack/react-query\";\nimport type { Hash } from \"viem\";\nimport { useConfig, useTransaction } from \"wagmi\";\n\nexport function useEnsureTxResponse(): EnsureTxResponseFn {\n  const queryClient = useQueryClient();\n  const wagmiConfig = useConfig();\n\n  return ensureTxResponseFactory({ queryClient, wagmiConfig });\n}\n\ntype UseTxResponseInput = {\n  hash?: Hash;\n  chainId?: SupportedChainId;\n  enabled?: boolean;\n};\n\nexport function useTxResponse({\n  hash,\n  chainId,\n  enabled = true,\n}: UseTxResponseInput) {\n  const ensureTxResponse = useEnsureTxResponse();\n\n  const txResponseQuery = useTransaction({\n    hash,\n    chainId,\n    query: { enabled: !!hash && enabled },\n  });\n\n  return {\n    query: txResponseQuery,\n    ensureTxResponse,\n  };\n}\n"],"mappings":";;;;;AASA,SAAOO,IAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EACLC,IAAoBP,GAAgB,EACpCQ,IAAoBN,GAAW,EAACO;AAE4B,QAF5BJ,EAAA,OAAAE,KAAAF,EAAA,OAAAG,KAEzBC,IAAAX,EAAwB;EAAAS;EAAAC;EAA4B,CAAC,EAAAH,EAAA,KAAAE,GAAAF,EAAA,KAAAG,GAAAH,EAAA,KAAAI,KAAAA,IAAAJ,EAAA,IAArDI;;AAST,SAAOK,EAAAL,GAAA;CAAA,IAAAJ,IAAAC,EAAA,EAAA,EAAuB,EAAAK,SAAAC,YAAAC,SAAAE,MAAAN,GAG5BI,IAAAE,MAAAC,KAAAA,IAAA,KAAAD,GAEAE,IAAyBb,GAAqB,EAK1Bc,IAAA,CAAC,CAACP,KAAFE,GAAiBM;AAAA,CAAAd,EAAA,OAAAa,IAAEC,IAAAd,EAAA,MAA9Bc,IAAA,EAAAN,SAAWK,GAAmB,EAAAb,EAAA,KAAAa,GAAAb,EAAA,KAAAc;CAAA,IAAAC;AAAA,CAAAf,EAAA,OAAAO,KAAAP,EAAA,OAAAM,KAAAN,EAAA,OAAAc,KAHAC,IAAA;EAAAT;EAAAC;EAAAS,OAG9BF;EACR,EAAAd,EAAA,KAAAO,GAAAP,EAAA,KAAAM,GAAAN,EAAA,KAAAc,GAAAd,EAAA,KAAAe,KAAAA,IAAAf,EAAA;CAJD,IAAAiB,IAAwBnB,EAAeiB,EAIrC,EAACG;AAKF,QALElB,EAAA,OAAAY,KAAAZ,EAAA,OAAAiB,KAEIC,IAAA;EAAAF,OACEC;EAAeL;EAEvB,EAAAZ,EAAA,KAAAY,GAAAZ,EAAA,KAAAiB,GAAAjB,EAAA,KAAAkB,KAAAA,IAAAlB,EAAA,IAHMkB"}

package/dist/hooks/txs/queries/useWalletCanReplaceTx.d.ts

@@ -0,0 +1,2 @@
+export declare function useWalletCanReplaceTx(): boolean;
+//# sourceMappingURL=useWalletCanReplaceTx.d.ts.map

package/dist/hooks/txs/queries/useWalletCanReplaceTx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletCanReplaceTx.d.ts","sourceRoot":"","sources":["../../../../src/hooks/txs/queries/useWalletCanReplaceTx.ts"],"names":[],"mappings":"AAsBA,wBAAgB,qBAAqB,IAAI,OAAO,CAqB/C"}

package/dist/hooks/txs/queries/useWalletCanReplaceTx.js

@@ -0,0 +1,16 @@
+import { useIsAccountContract as e } from "../../getCode/useIsAccountContract.js";
+import { useWalletMetadata as t } from "../../../components/web3/ConnectWallets/walletIcons.js";
+import { c as n } from "react-compiler-runtime";
+import { useAccount as r } from "wagmi";
+//#region src/hooks/txs/queries/useWalletCanReplaceTx.ts
+var i = /Rabby|Ledger Wallet/i;
+function a() {
+	let a = n(2), { connector: o } = r(), s = t(o), { data: c } = e(), l;
+	a[0] === s ? l = a[1] : (l = !!s?.name && !i.test(s.name), a[0] = s, a[1] = l);
+	let u = l, d = c?.isContract ?? !1;
+	return !!o && !!s && !u && !d;
+}
+//#endregion
+export { a as useWalletCanReplaceTx };
+
+//# sourceMappingURL=useWalletCanReplaceTx.js.map

package/dist/hooks/txs/queries/useWalletCanReplaceTx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletCanReplaceTx.js","names":["useAccount","useWalletMetadata","useIsAccountContract","SUPPORTED_WALLETS_REGEX","useWalletCanReplaceTx","$","_c","connector","walletMetadata","data","accountContractData","t0","name","test","isKnownUnsupportedWallet","isSmartContract","isContract"],"sources":["../../../../src/hooks/txs/queries/useWalletCanReplaceTx.ts"],"sourcesContent":["import { useAccount } from \"wagmi\";\nimport { useWalletMetadata } from \"@/components/web3/ConnectWallets/walletIcons\";\nimport { useIsAccountContract } from \"@/hooks/getCode/useIsAccountContract\";\n/**\n * Some of the tested wallets:\n *\n * | Wallet        | Test result                                                                                              | Supports | metadata.name |\n * | ------------- | -------------------------------------------------------------------------------------------------------- | -------- | ------------- |\n * | Rabby         | Works, but ignores gasPrice params                                                                       | ✓        | Rabby Wallet  |\n * | MetaMask      | nonce is ignored, gasPrice params accepted                                                               | ✗        | MetaMask      |\n * | TrustWallet   | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Trust Wallet  |\n * | BitGet Wallet | ignores gasPrice params, accepts nonce, but doesn't allow to submit tx with same nonce to replace        | ✗        | Bitget Wallet |\n * | Rainbow       | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Rainbow       |\n * | Phantom       | accepts nonce, but doesn't allow to submit tx with same nonce to replace, ignores gasPrice params        | ✗        | Phantom       |\n * | Enkrypt       | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Enkrypt       |\n * | Ledger Live   | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Ledger Live   |\n * | Ledger Button | supports nonce, should take all params as is                                                             | ✓        | Ledger Wallet |\n *\n */\n\nconst SUPPORTED_WALLETS_REGEX = /Rabby|Ledger Wallet/i; // wallets known to support replaceTx nonce override\n\nexport function useWalletCanReplaceTx(): boolean {\n  const { connector } = useAccount();\n  const walletMetadata = useWalletMetadata(connector);\n  const { data: accountContractData } = useIsAccountContract();\n\n  // 1. Check if Wallet is Metamask (injected wallet or through WalletConnect)\n  // Metamask ignores txParams.nonce and doesn't allow replacing txs\n  const isKnownUnsupportedWallet =\n    !!walletMetadata?.name &&\n    !SUPPORTED_WALLETS_REGEX.test(walletMetadata.name);\n\n  // 2. Check if user account is a SmartContract\n  // SmartContracts have their own logic for replacing pending txs (if any)\n  const isSmartContract = accountContractData?.isContract ?? false;\n\n  return (\n    !!connector &&\n    !!walletMetadata &&\n    !isKnownUnsupportedWallet &&\n    !isSmartContract\n  );\n}\n"],"mappings":";;;;;AAoBA,IAAMG,IAA0B;AAEhC,SAAOC,IAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EACL,EAAAC,iBAAsBP,GAAY,EAClCQ,IAAuBP,EAAkBM,EAAU,EACnD,EAAAE,MAAAC,MAAsCR,GAAsB,EAACS;AAAA,CAAAN,EAAA,OAAAG,IAMTG,IAAAN,EAAA,MADlDM,IAAA,CAAC,CAACH,GAAcI,QAAhB,CACCT,EAAuBU,KAAML,EAAcI,KAAM,EAAAP,EAAA,KAAAG,GAAAH,EAAA,KAAAM;CAFpD,IAAAG,IACEH,GAKFI,IAAwBL,GAAmBM,cAAnB;AAAyC,QAG/D,CAAC,CAACT,KAAF,CACC,CAACC,KADF,CAECM,KAFD,CAGCC"}

package/dist/hooks/txs/queries/utils.js

@@ -1,14 +1,15 @@
-import { isFilledArray } from '../../../lib/utils/tuple.js';
-
-function isTransactionReceipt(data) {
-  return typeof data === "object" && data !== null && "blockHash" in data && "transactionHash" in data && "status" in data && "gasUsed" in data;
+import { isFilledArray as e } from "../../../lib/utils/tuple.js";
+//#region src/hooks/txs/queries/utils.ts
+function t(e) {
+	return typeof e == "object" && !!e && "blockHash" in e && "transactionHash" in e && "status" in e && "gasUsed" in e;
 }
-function isWaitForCallsStatusData(data) {
-  return typeof data === "object" && data !== null && "id" in data && "status" in data && "atomic" in data;
+function n(e) {
+	return typeof e == "object" && !!e && "id" in e && "status" in e && "atomic" in e;
 }
-function isReceiptsInWaitForCallsStatusData(data) {
-  return Array.isArray(data.receipts) && isFilledArray(data.receipts);
+function r(t) {
+	return Array.isArray(t.receipts) && e(t.receipts);
 }
+//#endregion
+export { r as isReceiptsInWaitForCallsStatusData, t as isTransactionReceipt, n as isWaitForCallsStatusData };
 
-export { isReceiptsInWaitForCallsStatusData, isTransactionReceipt, isWaitForCallsStatusData };
-//# sourceMappingURL=utils.js.map
+//# sourceMappingURL=utils.js.map

package/dist/hooks/txs/queries/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../../../src/hooks/txs/queries/utils.ts"],"sourcesContent":["import type { WaitForCallsStatusDataWithReceipts } from \"@/hooks/batch/useAwaitCalls\";\nimport { isFilledArray } from \"@/lib/utils/tuple\";\nimport type { TransactionReceipt } from \"viem\";\nimport type { WaitForCallsStatusData } from \"wagmi/query\";\n\nexport function isTransactionReceipt(\n  data: unknown\n): data is TransactionReceipt {\n  return (\n    typeof data === \"object\" &&\n    data !== null &&\n    \"blockHash\" in data &&\n    \"transactionHash\" in data &&\n    \"status\" in data &&\n    \"gasUsed\" in data\n  );\n}\n\nexport function isWaitForCallsStatusData(\n  data: unknown\n): data is WaitForCallsStatusData {\n  return (\n    typeof data === \"object\" &&\n    data !== null &&\n    \"id\" in data &&\n    \"status\" in data &&\n    \"atomic\" in data\n  );\n}\n\nexport function isReceiptsInWaitForCallsStatusData(\n  data: WaitForCallsStatusData\n): data is WaitForCallsStatusDataWithReceipts {\n  return Array.isArray(data.receipts) && isFilledArray(data.receipts);\n}\n"],"names":["isTransactionReceipt","data","isWaitForCallsStatusData","isReceiptsInWaitForCallsStatusData","Array","isArray","receipts","isFilledArray"],"mappings":";;AAKO,SAASA,qBACdC,IAAAA,EAC4B;AAC5B,EAAA,OACE,OAAOA,IAAAA,KAAS,QAAA,IAChBA,IAAAA,KAAS,IAAA,IACT,WAAA,IAAeA,IAAAA,IACf,iBAAA,IAAqBA,IAAAA,IACrB,QAAA,IAAYA,IAAAA,IACZ,SAAA,IAAaA,IAAAA;AAEjB;AAEO,SAASC,yBACdD,IAAAA,EACgC;AAChC,EAAA,OACE,OAAOA,SAAS,QAAA,IAChBA,IAAAA,KAAS,QACT,IAAA,IAAQA,IAAAA,IACR,QAAA,IAAYA,IAAAA,IACZ,QAAA,IAAYA,IAAAA;AAEhB;AAEO,SAASE,mCACdF,IAAAA,EAC4C;AAC5C,EAAA,OAAOG,MAAMC,OAAAA,CAAQJ,IAAAA,CAAKK,QAAQ,CAAA,IAAKC,aAAAA,CAAcN,KAAKK,QAAQ,CAAA;AACpE;;;;"}
+{"version":3,"file":"utils.js","names":["WaitForCallsStatusDataWithReceipts","isFilledArray","TransactionReceipt","WaitForCallsStatusData","isTransactionReceipt","data","isWaitForCallsStatusData","isReceiptsInWaitForCallsStatusData","Array","isArray","receipts"],"sources":["../../../../src/hooks/txs/queries/utils.ts"],"sourcesContent":["import type { WaitForCallsStatusDataWithReceipts } from \"@/hooks/batch/useAwaitCalls\";\nimport { isFilledArray } from \"@/lib/utils/tuple\";\nimport type { TransactionReceipt } from \"viem\";\nimport type { WaitForCallsStatusData } from \"wagmi/query\";\n\nexport function isTransactionReceipt(\n  data: unknown\n): data is TransactionReceipt {\n  return (\n    typeof data === \"object\" &&\n    data !== null &&\n    \"blockHash\" in data &&\n    \"transactionHash\" in data &&\n    \"status\" in data &&\n    \"gasUsed\" in data\n  );\n}\n\nexport function isWaitForCallsStatusData(\n  data: unknown\n): data is WaitForCallsStatusData {\n  return (\n    typeof data === \"object\" &&\n    data !== null &&\n    \"id\" in data &&\n    \"status\" in data &&\n    \"atomic\" in data\n  );\n}\n\nexport function isReceiptsInWaitForCallsStatusData(\n  data: WaitForCallsStatusData\n): data is WaitForCallsStatusDataWithReceipts {\n  return Array.isArray(data.receipts) && isFilledArray(data.receipts);\n}\n"],"mappings":";;AAKA,SAAgBI,EACdC,GAC4B;AAC5B,QACE,OAAOA,KAAS,cAChBA,KACA,eAAeA,KACf,qBAAqBA,KACrB,YAAYA,KACZ,aAAaA;;AAIjB,SAAgBC,EACdD,GACgC;AAChC,QACE,OAAOA,KAAS,cAChBA,KACA,QAAQA,KACR,YAAYA,KACZ,YAAYA;;AAIhB,SAAgBE,EACdF,GAC4C;AAC5C,QAAOG,MAAMC,QAAQJ,EAAKK,SAAS,IAAIT,EAAcI,EAAKK,SAAS"}

package/dist/hooks/useAvailableCrosses.js

@@ -1,76 +1,38 @@
-import { d as distExports } from '../_virtual/index.js';
-import { isSupportedChainId } from '../lib/web3/wagmi/utils.js';
-import 'react';
-import { useGetBridgeInfo } from './useBridgeInfo.js';
-import { emptyArray } from '../lib/constants/index.js';
-import { getBridgeInfoQueryData } from './swap/prices/delta/queries/bridgeInfo/getBridgeInfoQueryData.js';
-
-function useAvailableCrosses(t0) {
-  const $ = distExports.c(8);
-  const {
-    fromChainId,
-    mode
-  } = t0;
-  let t1;
-  if ($[0] !== mode) {
-    t1 = {
-      mode
-    };
-    $[0] = mode;
-    $[1] = t1;
-  } else {
-    t1 = $[1];
-  }
-  const {
-    data: bridgeInfo,
-    error,
-    isLoading
-  } = useGetBridgeInfo(t1);
-  const acrossTokenAddresses = bridgeInfo?.[fromChainId];
-  let t2;
-  bb0: {
-    if (!acrossTokenAddresses && !isLoading) {
-      t2 = emptyArray;
-      break bb0;
-    }
-    let t32;
-    if ($[2] !== acrossTokenAddresses) {
-      t32 = acrossTokenAddresses && Object.keys(acrossTokenAddresses).map(Number).filter(isSupportedChainId);
-      $[2] = acrossTokenAddresses;
-      $[3] = t32;
-    } else {
-      t32 = $[3];
-    }
-    t2 = t32;
-  }
-  const availableCrosses = t2;
-  let t3;
-  if ($[4] !== availableCrosses || $[5] !== error || $[6] !== isLoading) {
-    t3 = {
-      availableCrosses,
-      error,
-      isLoading
-    };
-    $[4] = availableCrosses;
-    $[5] = error;
-    $[6] = isLoading;
-    $[7] = t3;
-  } else {
-    t3 = $[7];
-  }
-  return t3;
+import { emptyArray as e } from "../lib/constants/index.js";
+import { isSupportedChainId as t } from "../lib/web3/wagmi/utils.js";
+import { getBridgeInfoQueryData as n } from "./swap/prices/delta/queries/bridgeInfo/getBridgeInfoQueryData.js";
+import { useGetBridgeInfo as r } from "./useBridgeInfo.js";
+import { c as i } from "react-compiler-runtime";
+import "react";
+//#region src/hooks/useAvailableCrosses.ts
+function a(n) {
+	let a = i(8), { fromChainId: o, mode: s } = n, c;
+	a[0] === s ? c = a[1] : (c = { mode: s }, a[0] = s, a[1] = c);
+	let { data: l, error: u, isLoading: d } = r(c), f = l?.[o], p;
+	bb0: {
+		if (!f && !d) {
+			p = e;
+			break bb0;
+		}
+		let n;
+		a[2] === f ? n = a[3] : (n = f && Object.keys(f).map(Number).filter(t), a[2] = f, a[3] = n), p = n;
+	}
+	let m = p, h;
+	return a[4] !== m || a[5] !== u || a[6] !== d ? (h = {
+		availableCrosses: m,
+		error: u,
+		isLoading: d
+	}, a[4] = m, a[5] = u, a[6] = d, a[7] = h) : h = a[7], h;
 }
-function getAvailableCrosses({
-  fromChainId,
-  mode
-}) {
-  const cachedBridgeInfo = getBridgeInfoQueryData(mode);
-  if (!cachedBridgeInfo) return emptyArray;
-  const acrossTokenAddresses = cachedBridgeInfo[fromChainId];
-  if (!acrossTokenAddresses) return emptyArray;
-  const availableCrosses = Object.keys(acrossTokenAddresses).map(Number).filter(isSupportedChainId);
-  return Array.from(new Set(availableCrosses));
+function o({ fromChainId: r, mode: i }) {
+	let a = n(i);
+	if (!a) return e;
+	let o = a[r];
+	if (!o) return e;
+	let s = Object.keys(o).map(Number).filter(t);
+	return Array.from(new Set(s));
 }
+//#endregion
+export { o as getAvailableCrosses, a as useAvailableCrosses };
 
-export { getAvailableCrosses, useAvailableCrosses };
-//# sourceMappingURL=useAvailableCrosses.js.map
+//# sourceMappingURL=useAvailableCrosses.js.map

package/dist/hooks/useAvailableCrosses.js.map

@@ -1 +1 @@
-{"version":3,"file":"useAvailableCrosses.js","sources":["../../src/hooks/useAvailableCrosses.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport { isSupportedChainId } from \"@/lib/web3/wagmi/utils\";\nimport { useMemo } from \"react\";\nimport { useGetBridgeInfo } from \"./useBridgeInfo\";\nimport { emptyArray } from \"@/lib/constants\";\nimport { type BridgeInfoMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\nimport { getBridgeInfoQueryData } from \"./swap/prices/delta/queries/bridgeInfo/getBridgeInfoQueryData\";\n\nexport function useAvailableCrosses({\n  fromChainId,\n  mode,\n}: {\n  fromChainId: SupportedChainId;\n  mode: BridgeInfoMode;\n}): {\n  availableCrosses?: SupportedChainId[];\n  error: Error | null;\n  isLoading: boolean;\n} {\n  const { data: bridgeInfo, error, isLoading } = useGetBridgeInfo({ mode });\n  const acrossTokenAddresses = bridgeInfo?.[fromChainId];\n  const availableCrosses = useMemo(() => {\n    if (!acrossTokenAddresses && !isLoading) return emptyArray;\n    return (\n      acrossTokenAddresses &&\n      Object.keys(acrossTokenAddresses).map(Number).filter(isSupportedChainId)\n    );\n  }, [acrossTokenAddresses, isLoading]);\n\n  return { availableCrosses, error, isLoading };\n}\n\nexport function getAvailableCrosses({\n  fromChainId,\n  mode,\n}: {\n  fromChainId: SupportedChainId;\n  mode: BridgeInfoMode;\n}): SupportedChainId[] {\n  const cachedBridgeInfo = getBridgeInfoQueryData(mode);\n  if (!cachedBridgeInfo) return emptyArray;\n\n  const acrossTokenAddresses = cachedBridgeInfo[fromChainId];\n  if (!acrossTokenAddresses) return emptyArray;\n\n  const availableCrosses = Object.keys(acrossTokenAddresses)\n    .map(Number)\n    .filter(isSupportedChainId);\n\n  return Array.from(new Set(availableCrosses));\n}\n"],"names":["useAvailableCrosses","t0","$","_c","fromChainId","mode","t1","data","bridgeInfo","error","isLoading","useGetBridgeInfo","acrossTokenAddresses","t2","bb0","emptyArray","t3","Object","keys","map","Number","filter","isSupportedChainId","availableCrosses","getAvailableCrosses","cachedBridgeInfo","getBridgeInfoQueryData","Array","from","Set"],"mappings":"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"}
+{"version":3,"file":"useAvailableCrosses.js","names":["SupportedChainId","isSupportedChainId","useMemo","useGetBridgeInfo","emptyArray","BridgeInfoMode","getBridgeInfoQueryData","useAvailableCrosses","t0","$","_c","fromChainId","mode","t1","data","bridgeInfo","error","isLoading","acrossTokenAddresses","t2","bb0","t3","Object","keys","map","Number","filter","availableCrosses","getAvailableCrosses","cachedBridgeInfo","Array","from","Set"],"sources":["../../src/hooks/useAvailableCrosses.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport { isSupportedChainId } from \"@/lib/web3/wagmi/utils\";\nimport { useMemo } from \"react\";\nimport { useGetBridgeInfo } from \"./useBridgeInfo\";\nimport { emptyArray } from \"@/lib/constants\";\nimport { type BridgeInfoMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\nimport { getBridgeInfoQueryData } from \"./swap/prices/delta/queries/bridgeInfo/getBridgeInfoQueryData\";\n\nexport function useAvailableCrosses({\n  fromChainId,\n  mode,\n}: {\n  fromChainId: SupportedChainId;\n  mode: BridgeInfoMode;\n}): {\n  availableCrosses?: SupportedChainId[];\n  error: Error | null;\n  isLoading: boolean;\n} {\n  const { data: bridgeInfo, error, isLoading } = useGetBridgeInfo({ mode });\n  const acrossTokenAddresses = bridgeInfo?.[fromChainId];\n  const availableCrosses = useMemo(() => {\n    if (!acrossTokenAddresses && !isLoading) return emptyArray;\n    return (\n      acrossTokenAddresses &&\n      Object.keys(acrossTokenAddresses).map(Number).filter(isSupportedChainId)\n    );\n  }, [acrossTokenAddresses, isLoading]);\n\n  return { availableCrosses, error, isLoading };\n}\n\nexport function getAvailableCrosses({\n  fromChainId,\n  mode,\n}: {\n  fromChainId: SupportedChainId;\n  mode: BridgeInfoMode;\n}): SupportedChainId[] {\n  const cachedBridgeInfo = getBridgeInfoQueryData(mode);\n  if (!cachedBridgeInfo) return emptyArray;\n\n  const acrossTokenAddresses = cachedBridgeInfo[fromChainId];\n  if (!acrossTokenAddresses) return emptyArray;\n\n  const availableCrosses = Object.keys(acrossTokenAddresses)\n    .map(Number)\n    .filter(isSupportedChainId);\n\n  return Array.from(new Set(availableCrosses));\n}\n"],"mappings":";;;;;;;AAQA,SAAOO,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EAA6B,EAAAC,gBAAAC,YAAAJ,GAMnCK;AAAA,CAAAJ,EAAA,OAAAG,IAKyEC,IAAAJ,EAAA,MAARI,IAAA,EAAAD,SAAQ,EAAAH,EAAA,KAAAG,GAAAH,EAAA,KAAAI;CAAxE,IAAA,EAAAC,MAAAC,GAAAC,UAAAC,iBAA+Cd,EAAiBU,EAAS,EACzEK,IAA6BH,IAAaJ,IAAaQ;AAAAC,MAAA;AAErD,MAAI,CAACF,KAAD,CAA0BD,GAAS;AAAEE,OAAOf;AAAP,SAAAgB;;EAAkB,IAAAC;AAC3DF,EAD2DV,EAAA,OAAAS,IAGeG,IAAAZ,EAAA,MADxEY,IAAAH,KACAI,OAAMC,KAAML,EAAqB,CAAAM,IAAKC,OAAO,CAAAC,OAAQzB,EAAmB,EAAAQ,EAAA,KAAAS,GAAAT,EAAA,KAAAY,IAF1EF,IACEE;;CAHJ,IAAAM,IAAyBR,GAMaE;AAEO,QAFPZ,EAAA,OAAAkB,KAAAlB,EAAA,OAAAO,KAAAP,EAAA,OAAAQ,KAE/BI,IAAA;EAAAM;EAAAX;EAAAC;EAAsC,EAAAR,EAAA,KAAAkB,GAAAlB,EAAA,KAAAO,GAAAP,EAAA,KAAAQ,GAAAR,EAAA,KAAAY,KAAAA,IAAAZ,EAAA,IAAtCY;;AAGT,SAAgBO,EAAoB,EAClCjB,gBACAC,WAIqB;CACrB,IAAMiB,IAAmBvB,EAAuBM,EAAK;AACrD,KAAI,CAACiB,EAAkB,QAAOzB;CAE9B,IAAMc,IAAuBW,EAAiBlB;AAC9C,KAAI,CAACO,EAAsB,QAAOd;CAElC,IAAMuB,IAAmBL,OAAOC,KAAKL,EAAqB,CACvDM,IAAIC,OAAO,CACXC,OAAOzB,EAAmB;AAE7B,QAAO6B,MAAMC,KAAK,IAAIC,IAAIL,EAAiB,CAAC"}

package/dist/hooks/useBreakpoints.js

@@ -1,22 +1,12 @@
-import { d as distExports } from '../_virtual/index.js';
-import { isOverMdAtom } from '../core/state/containerAtom.js';
-import { useAtomValue } from '../core/store.js';
-
-function useBreakpoints() {
-  const $ = distExports.c(2);
-  const isOverMd = useAtomValue(isOverMdAtom);
-  let t0;
-  if ($[0] !== isOverMd) {
-    t0 = {
-      isOverMd
-    };
-    $[0] = isOverMd;
-    $[1] = t0;
-  } else {
-    t0 = $[1];
-  }
-  return t0;
+import { useAtomValue as e } from "../core/store.js";
+import { isOverMdAtom as t } from "../core/state/containerAtom.js";
+import { c as n } from "react-compiler-runtime";
+//#region src/hooks/useBreakpoints.ts
+function r() {
+	let r = n(2), i = e(t), a;
+	return r[0] === i ? a = r[1] : (a = { isOverMd: i }, r[0] = i, r[1] = a), a;
 }
+//#endregion
+export { r as useBreakpoints };
 
-export { useBreakpoints };
-//# sourceMappingURL=useBreakpoints.js.map
+//# sourceMappingURL=useBreakpoints.js.map

package/dist/hooks/useBreakpoints.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBreakpoints.js","sources":["../../src/hooks/useBreakpoints.ts"],"sourcesContent":["import { isOverMdAtom } from \"@/core/state/containerAtom\";\nimport { useAtomValue } from \"@/core/store\";\n\nexport function useBreakpoints() {\n  const isOverMd = useAtomValue(isOverMdAtom);\n\n  return { isOverMd };\n}\n"],"names":["useBreakpoints","$","_c","isOverMd","useAtomValue","isOverMdAtom","t0"],"mappings":";;;;AAGO,SAAAA,cAAAA,GAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACL,EAAA,MAAAC,QAAAA,GAAiBC,aAAaC,YAAY,CAAA;AAAE,EAAA,IAAAC,EAAAA;AAAA,EAAA,IAAAL,CAAAA,QAAAE,QAAAA,EAAA;AAErCG,IAAAA,EAAAA,GAAA;AAAA,MAAAH;AAAAA,KAAW;AAACF,IAAAA,CAAAA,MAAAE,QAAAA;AAAAF,IAAAA,CAAAA,MAAAK,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAL,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAAZK,EAAAA;AAAY;;;;"}
+{"version":3,"file":"useBreakpoints.js","names":["isOverMdAtom","useAtomValue","useBreakpoints","$","_c","isOverMd","t0"],"sources":["../../src/hooks/useBreakpoints.ts"],"sourcesContent":["import { isOverMdAtom } from \"@/core/state/containerAtom\";\nimport { useAtomValue } from \"@/core/store\";\n\nexport function useBreakpoints() {\n  const isOverMd = useAtomValue(isOverMdAtom);\n\n  return { isOverMd };\n}\n"],"mappings":";;;;AAGA,SAAOE,IAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EACLC,IAAiBJ,EAAaD,EAAa,EAACM;AAEzB,QAFyBH,EAAA,OAAAE,IAEzBC,IAAAH,EAAA,MAAZG,IAAA,EAAAD,aAAY,EAAAF,EAAA,KAAAE,GAAAF,EAAA,KAAAG,IAAZA"}

package/dist/hooks/useBridgeInfo.d.ts

@@ -1,6 +1,6 @@
 import { UseQueryResult } from '@tanstack/react-query';
 import { BridgeInfo } from '@velora-dex/sdk';
-import { BridgeInfoMode } from './swap/prices/delta/queries/bridgeInfo/types';
+import { BridgeInfoMode } from './swap/prices/delta/queries/bridgeInfo/useBridgeInfo';
 export declare function useGetBridgeInfo({ mode, }: {
     mode: BridgeInfoMode;
 }): UseQueryResult<BridgeInfo, Error>;

package/dist/hooks/useBridgeInfo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useBridgeInfo.d.ts","sourceRoot":"","sources":["../../src/hooks/useBridgeInfo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAEnF,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,GACL,EAAE;IACD,IAAI,EAAE,cAAc,CAAC;CACtB,GAAG,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,CAYpC"}
+{"version":3,"file":"useBridgeInfo.d.ts","sourceRoot":"","sources":["../../src/hooks/useBridgeInfo.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,sDAAsD,CAAC;AAE9D,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,GACL,EAAE;IACD,IAAI,EAAE,cAAc,CAAC;CACtB,GAAG,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,CAYpC"}

package/dist/hooks/useBridgeInfo.js

@@ -1,39 +1,20 @@
-import { d as distExports } from '../_virtual/index.js';
-import '@tanstack/react-query';
-import { useBridgeInfoQuery } from './swap/prices/delta/queries/bridgeInfo/useBridgeInfo.js';
-
-function useGetBridgeInfo(t0) {
-  const $ = distExports.c(3);
-  const {
-    mode
-  } = t0;
-  let t1;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t1 = {
-      staleTime: Infinity,
-      gcTime: Infinity
-    };
-    $[0] = t1;
-  } else {
-    t1 = $[0];
-  }
-  const t2 = mode === "swap";
-  let t3;
-  if ($[1] !== t2) {
-    t3 = {
-      query: t1,
-      input: {
-        allowBridgeAndSwap: t2
-      }
-    };
-    $[1] = t2;
-    $[2] = t3;
-  } else {
-    t3 = $[2];
-  }
-  const result = useBridgeInfoQuery(t3);
-  return result;
+import { useBridgeInfoQuery as e } from "./swap/prices/delta/queries/bridgeInfo/useBridgeInfo.js";
+import { c as t } from "react-compiler-runtime";
+import "@tanstack/react-query";
+//#region src/hooks/useBridgeInfo.ts
+function n(n) {
+	let r = t(3), { mode: i } = n, a;
+	r[0] === Symbol.for("react.memo_cache_sentinel") ? (a = {
+		staleTime: Infinity,
+		gcTime: Infinity
+	}, r[0] = a) : a = r[0];
+	let o = i === "swap", s;
+	return r[1] === o ? s = r[2] : (s = {
+		query: a,
+		input: { allowBridgeAndSwap: o }
+	}, r[1] = o, r[2] = s), e(s);
 }
+//#endregion
+export { n as useGetBridgeInfo };
 
-export { useGetBridgeInfo };
-//# sourceMappingURL=useBridgeInfo.js.map
+//# sourceMappingURL=useBridgeInfo.js.map

package/dist/hooks/useBridgeInfo.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBridgeInfo.js","sources":["../../src/hooks/useBridgeInfo.ts"],"sourcesContent":["import { type UseQueryResult } from \"@tanstack/react-query\";\nimport type { BridgeInfo } from \"@velora-dex/sdk\";\nimport { useBridgeInfoQuery } from \"./swap/prices/delta/queries/bridgeInfo/useBridgeInfo\";\nimport type { BridgeInfoMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\n\nexport function useGetBridgeInfo({\n  mode,\n}: {\n  mode: BridgeInfoMode;\n}): UseQueryResult<BridgeInfo, Error> {\n  const result = useBridgeInfoQuery({\n    query: {\n      staleTime: Infinity,\n      gcTime: Infinity,\n    },\n    input: {\n      allowBridgeAndSwap: mode === \"swap\",\n    },\n  });\n\n  return result;\n}\n"],"names":["useGetBridgeInfo","t0","$","_c","mode","t1","Symbol","for","staleTime","Infinity","gcTime","t2","t3","query","input","allowBridgeAndSwap","result","useBridgeInfoQuery"],"mappings":";;;;AAKO,SAAAA,iBAAAC,EAAAA,EAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AAA0B,EAAA,MAAA;AAAA,IAAAC;AAAAA,GAAA,GAAAH,EAAAA;AAIhC,EAAA,IAAAI,EAAAA;AAAA,EAAA,IAAAH,EAAA,CAAA,CAAA,KAAAI,MAAAA,CAAAC,GAAAA,CAAA,2BAAA,CAAA,EAAA;AAEUF,IAAAA,EAAAA,GAAA;AAAA,MAAAG,SAAAA,EACMC,QAAAA;AAAAA,MAAQC,MAAAA,EACXD;AAAAA,KACV;AAACP,IAAAA,CAAAA,MAAAG,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAH,EAAA,CAAA,CAAA;AAAA,EAAA;AAEqB,EAAA,MAAAS,KAAAP,IAAAA,KAAS,MAAA;AAAM,EAAA,IAAAQ,EAAAA;AAAA,EAAA,IAAAV,CAAAA,QAAAS,EAAAA,EAAA;AANLC,IAAAA,EAAAA,GAAA;AAAA,MAAAC,KAAAA,EACzBR,EAAAA;AAAAA,MAGNS,KAAAA,EACM;AAAA,QAAAC,kBAAAA,EACeJ;AAAAA;AACtB,KACF;AAACT,IAAAA,CAAAA,MAAAS,EAAAA;AAAAT,IAAAA,CAAAA,MAAAU,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAV,EAAA,CAAA,CAAA;AAAA,EAAA;AARD,EAAA,MAAAc,MAAAA,GAAeC,mBAAmBL,EAQjC,CAAA;AAAE,EAAA,OAEII,MAAAA;AAAM;;;;"}
+{"version":3,"file":"useBridgeInfo.js","names":["UseQueryResult","BridgeInfo","useBridgeInfoQuery","BridgeInfoMode","useGetBridgeInfo","t0","$","_c","mode","t1","Symbol","for","staleTime","Infinity","gcTime","t2","t3","query","input","allowBridgeAndSwap","result"],"sources":["../../src/hooks/useBridgeInfo.ts"],"sourcesContent":["import { type UseQueryResult } from \"@tanstack/react-query\";\nimport type { BridgeInfo } from \"@velora-dex/sdk\";\nimport {\n  useBridgeInfoQuery,\n  type BridgeInfoMode,\n} from \"./swap/prices/delta/queries/bridgeInfo/useBridgeInfo\";\n\nexport function useGetBridgeInfo({\n  mode,\n}: {\n  mode: BridgeInfoMode;\n}): UseQueryResult<BridgeInfo, Error> {\n  const result = useBridgeInfoQuery({\n    query: {\n      staleTime: Infinity,\n      gcTime: Infinity,\n    },\n    input: {\n      allowBridgeAndSwap: mode === \"swap\",\n    },\n  });\n\n  return result;\n}\n"],"mappings":";;;;AAOA,SAAOI,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EAA0B,EAAAC,YAAAH,GAIhCI;AAAA,CAAAH,EAAA,OAAAI,OAAAC,IAAA,4BAAA,IAEUF,IAAA;EAAAG,WACMC;EAAQC,QACXD;EACT,EAAAP,EAAA,KAAAG,KAAAA,IAAAH,EAAA;CAEqB,IAAAS,IAAAP,MAAS,QAAMQ;AAEpC,QAFoCV,EAAA,OAAAS,IAEtCC,IAAAV,EAAA,MARiCU,IAAA;EAAAC,OACzBR;EAGNS,OACM,EAAAC,oBACeJ,GACtB;EACD,EAAAT,EAAA,KAAAS,GAAAT,EAAA,KAAAU,IARcd,EAAmBc,EAQhC"}

package/dist/hooks/useBridgeProtocols.js

@@ -1,35 +1,22 @@
-import { d as distExports } from '../_virtual/index.js';
-import { useBridgeProtocolsQuery } from './swap/prices/delta/queries/bridgeProtocols/useBridgeProtocols.js';
-
-const createProtocolMapping = (data) => data.reduce((acc, {
-  protocol,
-  ...rest
-}) => {
-  const lowercasedProtocol = protocol.toLowerCase();
-  acc[lowercasedProtocol] = {
-    protocol: lowercasedProtocol,
-    ...rest
-  };
-  return acc;
+import { useBridgeProtocolsQuery as e } from "./swap/prices/delta/queries/bridgeProtocols/useBridgeProtocols.js";
+import { c as t } from "react-compiler-runtime";
+//#region src/hooks/useBridgeProtocols.ts
+var n = (e) => e.reduce((e, { protocol: t, ...n }) => {
+	let r = t.toLowerCase();
+	return e[r] = {
+		protocol: r,
+		...n
+	}, e;
 }, {});
-function useGetBridgeProtocolsMap() {
-  const $ = distExports.c(1);
-  let t0;
-  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
-    t0 = {
-      query: {
-        staleTime: Infinity,
-        gcTime: Infinity,
-        select: createProtocolMapping
-      }
-    };
-    $[0] = t0;
-  } else {
-    t0 = $[0];
-  }
-  const result = useBridgeProtocolsQuery(t0);
-  return result;
+function r() {
+	let r = t(1), i;
+	return r[0] === Symbol.for("react.memo_cache_sentinel") ? (i = { query: {
+		staleTime: Infinity,
+		gcTime: Infinity,
+		select: n
+	} }, r[0] = i) : i = r[0], e(i);
 }
+//#endregion
+export { r as useGetBridgeProtocolsMap };
 
-export { useGetBridgeProtocolsMap };
-//# sourceMappingURL=useBridgeProtocols.js.map
+//# sourceMappingURL=useBridgeProtocols.js.map

package/dist/hooks/useBridgeProtocols.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBridgeProtocols.js","sources":["../../src/hooks/useBridgeProtocols.ts"],"sourcesContent":["import type {\n  BridgeProtocolsMapping,\n  BridgeProtocolsReturn,\n} from \"./swap/prices/delta/queries/bridgeProtocols/types\";\nimport { useBridgeProtocolsQuery } from \"./swap/prices/delta/queries/bridgeProtocols/useBridgeProtocols\";\n\n// mapping {[protocol.toLowerCase()]: bridgeProtocolResponse} for faster access\nconst createProtocolMapping = (data: BridgeProtocolsReturn) =>\n  data.reduce<BridgeProtocolsMapping>((acc, { protocol, ...rest }) => {\n    const lowercasedProtocol = protocol.toLowerCase();\n    acc[lowercasedProtocol] = { protocol: lowercasedProtocol, ...rest };\n    return acc;\n  }, {});\n\nexport function useGetBridgeProtocolsMap() {\n  const result = useBridgeProtocolsQuery({\n    query: {\n      staleTime: Infinity,\n      gcTime: Infinity,\n      select: createProtocolMapping,\n    },\n  });\n\n  return result;\n}\n"],"names":["createProtocolMapping","data","reduce","acc","protocol","rest","lowercasedProtocol","toLowerCase","useGetBridgeProtocolsMap","$","_c","t0","Symbol","for","query","staleTime","Infinity","gcTime","select","result","useBridgeProtocolsQuery"],"mappings":";;;AAOA,MAAMA,wBAAwBA,CAACC,IAAAA,KAC7BA,IAAAA,CAAKC,MAAAA,CAA+B,CAACC,GAAAA,EAAK;AAAA,EAAEC,QAAAA;AAAAA,EAAU,GAAGC;AAAK,CAAA,KAAM;AAClE,EAAA,MAAMC,kBAAAA,GAAqBF,SAASG,WAAAA,EAAY;AAChDJ,EAAAA,GAAAA,CAAIG,kBAAkB,CAAA,GAAI;AAAA,IAAEF,QAAAA,EAAUE,kBAAAA;AAAAA,IAAoB,GAAGD;AAAAA,GAAK;AAClE,EAAA,OAAOF,GAAAA;AACT,CAAA,EAAG,EAAE,CAAA;AAEA,SAAAK,wBAAAA,GAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AAAA,EAAA,IAAAC,EAAAA;AAAA,EAAA,IAAAF,EAAA,CAAA,CAAA,KAAAG,MAAAA,CAAAC,GAAAA,CAAA,2BAAA,CAAA,EAAA;AACkCF,IAAAA,EAAAA,GAAA;AAAA,MAAAG,KAAAA,EAC9B;AAAA,QAAAC,SAAAA,EACMC,QAAAA;AAAAA,QAAQC,MAAAA,EACXD,QAAAA;AAAAA,QAAQE,MAAAA,EACRlB;AAAAA;AACV,KACF;AAACS,IAAAA,CAAAA,MAAAE,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAF,EAAA,CAAA,CAAA;AAAA,EAAA;AAND,EAAA,MAAAU,MAAAA,GAAeC,wBAAwBT,EAMtC,CAAA;AAAE,EAAA,OAEIQ,MAAAA;AAAM;;;;"}
+{"version":3,"file":"useBridgeProtocols.js","names":["BridgeProtocolsMapping","BridgeProtocolsReturn","useBridgeProtocolsQuery","createProtocolMapping","data","reduce","acc","protocol","rest","lowercasedProtocol","toLowerCase","useGetBridgeProtocolsMap","$","_c","t0","Symbol","for","query","staleTime","Infinity","gcTime","select","result"],"sources":["../../src/hooks/useBridgeProtocols.ts"],"sourcesContent":["import type {\n  BridgeProtocolsMapping,\n  BridgeProtocolsReturn,\n} from \"./swap/prices/delta/queries/bridgeProtocols/types\";\nimport { useBridgeProtocolsQuery } from \"./swap/prices/delta/queries/bridgeProtocols/useBridgeProtocols\";\n\n// mapping {[protocol.toLowerCase()]: bridgeProtocolResponse} for faster access\nconst createProtocolMapping = (data: BridgeProtocolsReturn) =>\n  data.reduce<BridgeProtocolsMapping>((acc, { protocol, ...rest }) => {\n    const lowercasedProtocol = protocol.toLowerCase();\n    acc[lowercasedProtocol] = { protocol: lowercasedProtocol, ...rest };\n    return acc;\n  }, {});\n\nexport function useGetBridgeProtocolsMap() {\n  const result = useBridgeProtocolsQuery({\n    query: {\n      staleTime: Infinity,\n      gcTime: Infinity,\n      select: createProtocolMapping,\n    },\n  });\n\n  return result;\n}\n"],"mappings":";;;AAOA,IAAMG,KAAyBC,MAC7BA,EAAKC,QAAgCC,GAAK,EAAEC,aAAU,GAAGC,QAAW;CAClE,IAAMC,IAAqBF,EAASG,aAAa;AAEjD,QADAJ,EAAIG,KAAsB;EAAEF,UAAUE;EAAoB,GAAGD;EAAM,EAC5DF;GACN,EAAE,CAAC;AAER,SAAOK,IAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EAAAC;AAOF,QAPEF,EAAA,OAAAG,OAAAC,IAAA,4BAAA,IACkCF,IAAA,EAAAG,OAC9B;EAAAC,WACMC;EAAQC,QACXD;EAAQE,QACRlB;EACV,EACD,EAAAS,EAAA,KAAAE,KAAAA,IAAAF,EAAA,IANcV,EAAwBY,EAMrC"}

package/dist/hooks/useCachedQueryError.js

@@ -1,11 +1,10 @@
-import { useRef } from 'react';
-
-function useCachedQueryError(query) {
-  const errorRef = useRef(query.error);
-  if (query.error) errorRef.current = query.error;
-  if (query.isSuccess) errorRef.current = null;
-  return errorRef.current;
+import { useRef as e } from "react";
+//#region src/hooks/useCachedQueryError.ts
+function t(t) {
+	let n = e(t.error);
+	return t.error && (n.current = t.error), t.isSuccess && (n.current = null), n.current;
 }
+//#endregion
+export { t as useCachedQueryError };
 
-export { useCachedQueryError };
-//# sourceMappingURL=useCachedQueryError.js.map
+//# sourceMappingURL=useCachedQueryError.js.map

package/dist/hooks/useCachedQueryError.js.map

@@ -1 +1 @@
-{"version":3,"file":"useCachedQueryError.js","sources":["../../src/hooks/useCachedQueryError.ts"],"sourcesContent":["import type { DefaultError, UseQueryResult } from \"@tanstack/react-query\";\nimport { useRef } from \"react\";\n\nexport function useCachedQueryError<TData = unknown, TError = DefaultError>(\n  query: UseQueryResult<TData, TError>\n): TError | null {\n  // keep track if last result was error\n  const errorRef = useRef(query.error);\n  // by itself isError resets when fetching\n\n  /* eslint-disable react-hooks/refs */\n  if (query.error) errorRef.current = query.error;\n  // keep errorRef until delta succeeds\n  if (query.isSuccess) errorRef.current = null;\n  /* eslint-disable react-hooks/refs */\n\n  return errorRef.current;\n}\n"],"names":["useCachedQueryError","query","errorRef","useRef","error","current","isSuccess"],"mappings":";;AAGO,SAASA,oBACdC,KAAAA,EACe;AAEf,EAAA,MAAMC,QAAAA,GAAWC,MAAAA,CAAOF,KAAAA,CAAMG,KAAK,CAAA;AAInC,EAAA,IAAIH,KAAAA,CAAMG,KAAAA,EAAOF,QAAAA,CAASG,OAAAA,GAAUJ,KAAAA,CAAMG,KAAAA;AAE1C,EAAA,IAAIH,KAAAA,CAAMK,SAAAA,EAAWJ,QAAAA,CAASG,OAAAA,GAAU,IAAA;AAGxC,EAAA,OAAOH,QAAAA,CAASG,OAAAA;AAClB;;;;"}
+{"version":3,"file":"useCachedQueryError.js","names":["DefaultError","UseQueryResult","useRef","useCachedQueryError","query","TData","TError","errorRef","error","current","isSuccess"],"sources":["../../src/hooks/useCachedQueryError.ts"],"sourcesContent":["import type { DefaultError, UseQueryResult } from \"@tanstack/react-query\";\nimport { useRef } from \"react\";\n\nexport function useCachedQueryError<TData = unknown, TError = DefaultError>(\n  query: UseQueryResult<TData, TError>\n): TError | null {\n  // keep track if last result was error\n  const errorRef = useRef(query.error);\n  // by itself isError resets when fetching\n\n  /* eslint-disable react-hooks/refs */\n  if (query.error) errorRef.current = query.error;\n  // keep errorRef until delta succeeds\n  if (query.isSuccess) errorRef.current = null;\n  /* eslint-disable react-hooks/refs */\n\n  return errorRef.current;\n}\n"],"mappings":";;AAGA,SAAgBG,EACdC,GACe;CAEf,IAAMG,IAAWL,EAAOE,EAAMI,MAAM;AASpC,QALIJ,EAAMI,UAAOD,EAASE,UAAUL,EAAMI,QAEtCJ,EAAMM,cAAWH,EAASE,UAAU,OAGjCF,EAASE"}

package/dist/hooks/useChainMatches.js

@@ -1,31 +1,15 @@
-import { d as distExports } from '../_virtual/index.js';
-import { useChainId, useAccount } from 'wagmi';
-
-function useChainMatches(forcedChainId) {
-  const $ = distExports.c(4);
-  const appChainId = useChainId();
-  const {
-    chainId: walletChainId,
-    isConnected
-  } = useAccount();
-  const walletChainMatchesAppChain = isConnected && !!walletChainId && appChainId === walletChainId;
-  const forcedChainMatchesWalletChain = isConnected && forcedChainId !== void 0 && walletChainId !== void 0 && forcedChainId === walletChainId;
-  let t0;
-  if ($[0] !== forcedChainMatchesWalletChain || $[1] !== isConnected || $[2] !== walletChainMatchesAppChain) {
-    t0 = {
-      isConnected,
-      walletChainMatchesAppChain,
-      forcedChainMatchesWalletChain
-    };
-    $[0] = forcedChainMatchesWalletChain;
-    $[1] = isConnected;
-    $[2] = walletChainMatchesAppChain;
-    $[3] = t0;
-  } else {
-    t0 = $[3];
-  }
-  return t0;
+import { c as e } from "react-compiler-runtime";
+import { useAccount as t, useChainId as n } from "wagmi";
+//#region src/hooks/useChainMatches.ts
+function r(r) {
+	let i = e(4), a = n(), { chainId: o, isConnected: s } = t(), c = s && !!o && a === o, l = s && r !== void 0 && o !== void 0 && r === o, u;
+	return i[0] !== l || i[1] !== s || i[2] !== c ? (u = {
+		isConnected: s,
+		walletChainMatchesAppChain: c,
+		forcedChainMatchesWalletChain: l
+	}, i[0] = l, i[1] = s, i[2] = c, i[3] = u) : u = i[3], u;
 }
+//#endregion
+export { r as useChainMatches };
 
-export { useChainMatches };
-//# sourceMappingURL=useChainMatches.js.map
+//# sourceMappingURL=useChainMatches.js.map

package/dist/hooks/useChainMatches.js.map

@@ -1 +1 @@
-{"version":3,"file":"useChainMatches.js","sources":["../../src/hooks/useChainMatches.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport { useAccount, useChainId } from \"wagmi\";\n\nexport function useChainMatches(forcedChainId?: SupportedChainId) {\n  const appChainId = useChainId();\n  const { chainId: walletChainId, isConnected } = useAccount();\n\n  const walletChainMatchesAppChain =\n    isConnected && !!walletChainId && appChainId === walletChainId;\n\n  const forcedChainMatchesWalletChain =\n    isConnected &&\n    forcedChainId !== undefined &&\n    walletChainId !== undefined &&\n    forcedChainId === walletChainId;\n\n  return {\n    isConnected,\n    walletChainMatchesAppChain,\n    forcedChainMatchesWalletChain,\n  };\n}\n"],"names":["useChainMatches","forcedChainId","$","_c","appChainId","useChainId","chainId","walletChainId","isConnected","useAccount","walletChainMatchesAppChain","forcedChainMatchesWalletChain","undefined","t0"],"mappings":";;;AAGO,SAAAA,gBAAAC,aAAAA,EAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACL,EAAA,MAAAC,aAAmBC,UAAAA,EAAW;AAC9B,EAAA,MAAA;AAAA,IAAAC,OAAAA,EAAAC,aAAAA;AAAAA,IAAAC;AAAAA,MAAgDC,UAAAA,EAAW;AAE3D,EAAA,MAAAC,0BAAAA,GACEF,WAAAA,IAAA,CAAgB,CAACD,iBAAiBH,UAAAA,KAAeG,aAAAA;AAEnD,EAAA,MAAAI,gCACEH,WAAAA,IACAP,aAAAA,KAAkBW,MAAAA,IAClBL,aAAAA,KAAkBK,UAClBX,aAAAA,KAAkBM,aAAAA;AAAc,EAAA,IAAAM,EAAAA;AAAA,EAAA,IAAAX,CAAAA,CAAA,CAAA,CAAA,KAAAS,6BAAAA,IAAAT,CAAAA,QAAAM,WAAAA,IAAAN,CAAAA,CAAA,CAAA,CAAA,KAAAQ,0BAAAA,EAAA;AAE3BG,IAAAA,EAAAA,GAAA;AAAA,MAAAL,WAAAA;AAAAA,MAAAE,0BAAAA;AAAAA,MAAAC;AAAAA,KAIP;AAACT,IAAAA,CAAAA,MAAAS,6BAAAA;AAAAT,IAAAA,CAAAA,MAAAM,WAAAA;AAAAN,IAAAA,CAAAA,MAAAQ,0BAAAA;AAAAR,IAAAA,CAAAA,MAAAW,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAX,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAJMW,EAAAA;AAIN;;;;"}
+{"version":3,"file":"useChainMatches.js","names":["SupportedChainId","useAccount","useChainId","useChainMatches","forcedChainId","$","_c","appChainId","chainId","walletChainId","isConnected","walletChainMatchesAppChain","forcedChainMatchesWalletChain","undefined","t0"],"sources":["../../src/hooks/useChainMatches.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport { useAccount, useChainId } from \"wagmi\";\n\nexport function useChainMatches(forcedChainId?: SupportedChainId) {\n  const appChainId = useChainId();\n  const { chainId: walletChainId, isConnected } = useAccount();\n\n  const walletChainMatchesAppChain =\n    isConnected && !!walletChainId && appChainId === walletChainId;\n\n  const forcedChainMatchesWalletChain =\n    isConnected &&\n    forcedChainId !== undefined &&\n    walletChainId !== undefined &&\n    forcedChainId === walletChainId;\n\n  return {\n    isConnected,\n    walletChainMatchesAppChain,\n    forcedChainMatchesWalletChain,\n  };\n}\n"],"mappings":";;;AAGA,SAAOG,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EACLC,IAAmBL,GAAY,EAC/B,EAAAM,SAAAC,GAAAC,mBAAgDT,GAAY,EAE5DU,IACED,KAAA,CAAgB,CAACD,KAAiBF,MAAeE,GAEnDG,IACEF,KACAN,MAAkBS,KAAAA,KAClBJ,MAAkBI,KAAAA,KAClBT,MAAkBK,GAAcK;AAMjC,QANiCT,EAAA,OAAAO,KAAAP,EAAA,OAAAK,KAAAL,EAAA,OAAAM,KAE3BG,IAAA;EAAAJ;EAAAC;EAAAC;EAIN,EAAAP,EAAA,KAAAO,GAAAP,EAAA,KAAAK,GAAAL,EAAA,KAAAM,GAAAN,EAAA,KAAAS,KAAAA,IAAAT,EAAA,IAJMS"}