@velora-dex/widget 0.8.4 → 0.8.5-dev.1

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

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

package/dist/hooks/useAvailableCrosses.d.ts

@@ -1,8 +1,8 @@
 import { SupportedChainId } from '../lib/web3/wagmi/types';
-import { BridgeInfoMode } from './swap/prices/delta/queries/bridgeInfo/types';
+import { BridgeRoutesMode } from './swap/prices/delta/queries/bridgeInfo/types';
 export declare function useAvailableCrosses({ fromChainId, mode, }: {
     fromChainId: SupportedChainId;
-    mode: BridgeInfoMode;
+    mode: BridgeRoutesMode;
 }): {
     availableCrosses?: SupportedChainId[];
     error: Error | null;
@@ -10,6 +10,6 @@ export declare function useAvailableCrosses({ fromChainId, mode, }: {
 };
 export declare function getAvailableCrosses({ fromChainId, mode, }: {
     fromChainId: SupportedChainId;
-    mode: BridgeInfoMode;
+    mode: BridgeRoutesMode;
 }): SupportedChainId[];
 //# sourceMappingURL=useAvailableCrosses.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"useAvailableCrosses.d.ts","sourceRoot":"","sources":["../../src/hooks/useAvailableCrosses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK/D,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAGnF,wBAAgB,mBAAmB,CAAC,EAClC,WAAW,EACX,IAAI,GACL,EAAE;IACD,WAAW,EAAE,gBAAgB,CAAC;IAC9B,IAAI,EAAE,cAAc,CAAC;CACtB,GAAG;IACF,gBAAgB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACtC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB,CAYA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,WAAW,EACX,IAAI,GACL,EAAE;IACD,WAAW,EAAE,gBAAgB,CAAC;IAC9B,IAAI,EAAE,cAAc,CAAC;CACtB,GAAG,gBAAgB,EAAE,CAYrB"}
+{"version":3,"file":"useAvailableCrosses.d.ts","sourceRoot":"","sources":["../../src/hooks/useAvailableCrosses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAK/D,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAGrF,wBAAgB,mBAAmB,CAAC,EAClC,WAAW,EACX,IAAI,GACL,EAAE;IACD,WAAW,EAAE,gBAAgB,CAAC;IAC9B,IAAI,EAAE,gBAAgB,CAAC;CACxB,GAAG;IACF,gBAAgB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACtC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;CACpB,CAYA;AAED,wBAAgB,mBAAmB,CAAC,EAClC,WAAW,EACX,IAAI,GACL,EAAE;IACD,WAAW,EAAE,gBAAgB,CAAC;IAC9B,IAAI,EAAE,gBAAgB,CAAC;CACxB,GAAG,gBAAgB,EAAE,CAYrB"}

package/dist/hooks/useAvailableCrosses.js.map

@@ -1 +1 @@
-{"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;CAAA,AAAAJ,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;CAAAC,KAAA;EAErD,IAAI,CAACF,KAAD,CAA0BD,GAAS;GAAEE,IAAOf;GAAP,MAAAgB;;EAAkB,IAAAC;EAC3DF,AAD2DV,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;CAEO,OAFPZ,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;CACrD,IAAI,CAACiB,GAAkB,OAAOzB;CAE9B,IAAMc,IAAuBW,EAAiBlB;CAC9C,IAAI,CAACO,GAAsB,OAAOd;CAElC,IAAMuB,IAAmBL,OAAOC,KAAKL,EAAqB,CACvDM,IAAIC,OAAO,CACXC,OAAOzB,EAAmB;CAE7B,OAAO6B,MAAMC,KAAK,IAAIC,IAAIL,EAAiB,CAAC"}
+{"version":3,"file":"useAvailableCrosses.js","names":["SupportedChainId","isSupportedChainId","useMemo","useGetBridgeInfo","emptyArray","BridgeRoutesMode","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 BridgeRoutesMode } 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: BridgeRoutesMode;\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: BridgeRoutesMode;\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}"],"mappings":";;;;;;;AAQA,SAAOO,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EAA6B,EAAAC,gBAAAC,YAAAJ,GAMnCK;CAAA,AAAAJ,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;CAAAC,KAAA;EAErD,IAAI,CAACF,KAAD,CAA0BD,GAAS;GAAEE,IAAOf;GAAP,MAAAgB;;EAAkB,IAAAC;EAC3DF,AAD2DV,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;CAEO,OAFPZ,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;CACrD,IAAI,CAACiB,GAAkB,OAAOzB;CAE9B,IAAMc,IAAuBW,EAAiBlB;CAC9C,IAAI,CAACO,GAAsB,OAAOd;CAElC,IAAMuB,IAAmBL,OAAOC,KAAKL,EAAqB,CACvDM,IAAIC,OAAO,CACXC,OAAOzB,EAAmB;CAE7B,OAAO6B,MAAMC,KAAK,IAAIC,IAAIL,EAAiB,CAAC"}

package/dist/hooks/useBridgeInfo.d.ts

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

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;AAE5D,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAEjG,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,GACL,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAC;CACxB,GAAG,cAAc,CAAC,UAAU,EAAE,KAAK,CAAC,CAYpC"}

package/dist/hooks/useBridgeInfo.js.map

@@ -1 +1 @@
-{"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 { 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"],"mappings":";;;;AAKA,SAAOI,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EAA0B,EAAAC,YAAAH,GAIhCI;CAAA,AAAAH,EAAA,OAAAI,OAAAC,IAAA,4BAAA,IAEUF,IAAA;EAAAG,WACMC;EAAQC,QACXD;EACT,EAAAP,EAAA,KAAAG,KAAAA,IAAAH,EAAA;CAEqB,IAAAS,IAAAP,MAAS,QAAMQ;CAEpC,OAFoCV,EAAA,OAAAS,IAEtCC,IAAAV,EAAA,MARiCU,IAAA;EAAAC,OACzBR;EAGNS,OACM,EAAAC,oBACeJ,GACtB;EACD,EAAAT,EAAA,KAAAS,GAAAT,EAAA,KAAAU,IARcd,EAAmBc,EAU3BI"}
+{"version":3,"file":"useBridgeInfo.js","names":["UseQueryResult","useBridgeInfoQuery","BridgeInfo","BridgeRoutesMode","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 { useBridgeInfoQuery } from \"./swap/prices/delta/queries/bridgeInfo/useBridgeInfo\";\nimport type { BridgeInfo, BridgeRoutesMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\n\nexport function useGetBridgeInfo({\n  mode,\n}: {\n  mode: BridgeRoutesMode;\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}"],"mappings":";;;;AAIA,SAAOI,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,EAA0B,EAAAC,YAAAH,GAIhCI;CAAA,AAAAH,EAAA,OAAAI,OAAAC,IAAA,4BAAA,IAEUF,IAAA;EAAAG,WACMC;EAAQC,QACXD;EACT,EAAAP,EAAA,KAAAG,KAAAA,IAAAH,EAAA;CAEqB,IAAAS,IAAAP,MAAS,QAAMQ;CAEpC,OAFoCV,EAAA,OAAAS,IAEtCC,IAAAV,EAAA,MARiCU,IAAA;EAAAC,OACzBR;EAGNS,OACM,EAAAC,oBACeJ,GACtB;EACD,EAAAT,EAAA,KAAAS,GAAAT,EAAA,KAAAU,IARcf,EAAmBe,EAU3BI"}

package/dist/hooks/useIsCrosschainPossible.d.ts

@@ -1,9 +1,9 @@
-import { BridgeInfoMode } from './swap/prices/delta/queries/bridgeInfo/types';
+import { BridgeRoutesMode } from './swap/prices/delta/queries/bridgeInfo/types';
 export declare function useIsCrosschainPossible({ fromChainId, toChainId, tokenAddress, mode, }: {
     fromChainId: number;
     toChainId?: number;
     tokenAddress?: string;
-    mode: BridgeInfoMode;
+    mode: BridgeRoutesMode;
 }): {
     hasTokens: boolean;
     isLoading: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"useIsCrosschainPossible.d.ts","sourceRoot":"","sources":["../../src/hooks/useIsCrosschainPossible.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAInF,wBAAgB,uBAAuB,CAAC,EACtC,WAAW,EACX,SAAS,EACT,YAAY,EACZ,IAAI,GACL,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,cAAc,CAAC;CACtB,GAAG;IACF,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CA2BA"}
+{"version":3,"file":"useIsCrosschainPossible.d.ts","sourceRoot":"","sources":["../../src/hooks/useIsCrosschainPossible.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAIrF,wBAAgB,uBAAuB,CAAC,EACtC,WAAW,EACX,SAAS,EACT,YAAY,EACZ,IAAI,GACL,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,gBAAgB,CAAC;CACxB,GAAG;IACF,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,oBAAoB,EAAE,OAAO,CAAC;CAC/B,CA2BA"}

package/dist/hooks/useIsCrosschainPossible.js.map

@@ -1 +1 @@
-{"version":3,"file":"useIsCrosschainPossible.js","names":["BridgeInfoMode","useIsTokenSupportedInDeltaQuery","useGetBridgeInfo","useIsCrosschainPossible","t0","$","_c","fromChainId","toChainId","tokenAddress","mode","t1","data","bridgeInfo","isLoading","isBridgeInfoLoading","tokenAddresses","undefined","hasTokens","length","t2","token","chainId","tokenSupported","isTokenSupportedLoading","isCrosschainPossible","t3"],"sources":["../../src/hooks/useIsCrosschainPossible.ts"],"sourcesContent":["import type { BridgeInfoMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\nimport { useIsTokenSupportedInDeltaQuery } from \"./swap/prices/delta/queries/useIsTokenSupportedInDelta\";\nimport { useGetBridgeInfo } from \"./useBridgeInfo\";\n\nexport function useIsCrosschainPossible({\n  fromChainId,\n  toChainId,\n  tokenAddress,\n  mode,\n}: {\n  fromChainId: number;\n  toChainId?: number;\n  tokenAddress?: string;\n  mode: BridgeInfoMode;\n}): {\n  hasTokens: boolean;\n  isLoading: boolean;\n  tokenSupported?: boolean;\n  tokenAddresses?: string[];\n  isCrosschainPossible: boolean;\n} {\n  const { data: bridgeInfo, isLoading: isBridgeInfoLoading } = useGetBridgeInfo(\n    { mode }\n  );\n\n  const tokenAddresses = toChainId\n    ? bridgeInfo?.[fromChainId]?.[toChainId]\n    : undefined;\n  const hasTokens = tokenAddresses !== undefined && tokenAddresses.length > 0;\n\n  const { data: tokenSupported, isLoading: isTokenSupportedLoading } =\n    useIsTokenSupportedInDeltaQuery({\n      token: tokenAddress,\n      chainId: fromChainId,\n    });\n\n  const isLoading = isBridgeInfoLoading || isTokenSupportedLoading;\n\n  const isCrosschainPossible = hasTokens && !!tokenSupported;\n\n  return {\n    hasTokens,\n    tokenSupported,\n    isLoading,\n    tokenAddresses,\n    isCrosschainPossible,\n  };\n}\n"],"mappings":";;;;AAIA,SAAOG,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,GAAA,EAAiC,EAAAC,gBAAAC,cAAAC,iBAAAC,YAAAN,GAUvCO;CAAA,AAAAN,EAAA,OAAAK,IAQWC,IAAAN,EAAA,MAARM,IAAA,EAAAD,SAAQ,EAAAL,EAAA,KAAAK,GAAAL,EAAA,KAAAM;CADV,IAAA,EAAAC,MAAAC,GAAAC,WAAAC,MAA6Db,EAC3DS,EACD,EAEDK,IAAuBR,IACnBK,IAAaN,KAAeC,KADTS,KAAAA,GAGvBC,IAAkBF,MAAmBC,KAAAA,KAAaD,EAAcG,SAAU,GAAEC;CAAA,AAAAf,EAAA,OAAAE,KAAAF,EAAA,OAAAI,KAG1CW,IAAA;EAAAC,OACvBZ;EAAYa,SACVf;EACV,EAAAF,EAAA,KAAAE,GAAAF,EAAA,KAAAI,GAAAJ,EAAA,KAAAe,KAAAA,IAAAf,EAAA;CAJH,IAAA,EAAAO,MAAAW,GAAAT,WAAAU,MACEvB,EAAgCmB,EAG9B,EAEJN,IAAkBC,KAAAS,GAElBC,IAA6BP,KAAA,CAAc,CAACK,GAAeG;CAQ1D,OAR0DrB,EAAA,OAAAa,KAAAb,EAAA,OAAAoB,KAAApB,EAAA,OAAAS,KAAAT,EAAA,OAAAW,KAAAX,EAAA,OAAAkB,KAEpDG,IAAA;EAAAR;EAAAK;EAAAT;EAAAE;EAAAS;EAMN,EAAApB,EAAA,KAAAa,GAAAb,EAAA,KAAAoB,GAAApB,EAAA,KAAAS,GAAAT,EAAA,KAAAW,GAAAX,EAAA,KAAAkB,GAAAlB,EAAA,MAAAqB,KAAAA,IAAArB,EAAA,KANMqB"}
+{"version":3,"file":"useIsCrosschainPossible.js","names":["BridgeRoutesMode","useIsTokenSupportedInDeltaQuery","useGetBridgeInfo","useIsCrosschainPossible","t0","$","_c","fromChainId","toChainId","tokenAddress","mode","t1","data","bridgeInfo","isLoading","isBridgeInfoLoading","tokenAddresses","undefined","hasTokens","length","t2","token","chainId","tokenSupported","isTokenSupportedLoading","isCrosschainPossible","t3"],"sources":["../../src/hooks/useIsCrosschainPossible.ts"],"sourcesContent":["import type { BridgeRoutesMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\nimport { useIsTokenSupportedInDeltaQuery } from \"./swap/prices/delta/queries/useIsTokenSupportedInDelta\";\nimport { useGetBridgeInfo } from \"./useBridgeInfo\";\n\nexport function useIsCrosschainPossible({\n  fromChainId,\n  toChainId,\n  tokenAddress,\n  mode,\n}: {\n  fromChainId: number;\n  toChainId?: number;\n  tokenAddress?: string;\n  mode: BridgeRoutesMode;\n}): {\n  hasTokens: boolean;\n  isLoading: boolean;\n  tokenSupported?: boolean;\n  tokenAddresses?: string[];\n  isCrosschainPossible: boolean;\n} {\n  const { data: bridgeInfo, isLoading: isBridgeInfoLoading } = useGetBridgeInfo(\n    { mode }\n  );\n\n  const tokenAddresses = toChainId\n    ? bridgeInfo?.[fromChainId]?.[toChainId]\n    : undefined;\n  const hasTokens = tokenAddresses !== undefined && tokenAddresses.length > 0;\n\n  const { data: tokenSupported, isLoading: isTokenSupportedLoading } =\n    useIsTokenSupportedInDeltaQuery({\n      token: tokenAddress,\n      chainId: fromChainId,\n    });\n\n  const isLoading = isBridgeInfoLoading || isTokenSupportedLoading;\n\n  const isCrosschainPossible = hasTokens && !!tokenSupported;\n\n  return {\n    hasTokens,\n    tokenSupported,\n    isLoading,\n    tokenAddresses,\n    isCrosschainPossible,\n  };\n}\n"],"mappings":";;;;AAIA,SAAOG,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,GAAA,EAAiC,EAAAC,gBAAAC,cAAAC,iBAAAC,YAAAN,GAUvCO;CAAA,AAAAN,EAAA,OAAAK,IAQWC,IAAAN,EAAA,MAARM,IAAA,EAAAD,SAAQ,EAAAL,EAAA,KAAAK,GAAAL,EAAA,KAAAM;CADV,IAAA,EAAAC,MAAAC,GAAAC,WAAAC,MAA6Db,EAC3DS,EACD,EAEDK,IAAuBR,IACnBK,IAAaN,KAAeC,KADTS,KAAAA,GAGvBC,IAAkBF,MAAmBC,KAAAA,KAAaD,EAAcG,SAAU,GAAEC;CAAA,AAAAf,EAAA,OAAAE,KAAAF,EAAA,OAAAI,KAG1CW,IAAA;EAAAC,OACvBZ;EAAYa,SACVf;EACV,EAAAF,EAAA,KAAAE,GAAAF,EAAA,KAAAI,GAAAJ,EAAA,KAAAe,KAAAA,IAAAf,EAAA;CAJH,IAAA,EAAAO,MAAAW,GAAAT,WAAAU,MACEvB,EAAgCmB,EAG9B,EAEJN,IAAkBC,KAAAS,GAElBC,IAA6BP,KAAA,CAAc,CAACK,GAAeG;CAQ1D,OAR0DrB,EAAA,OAAAa,KAAAb,EAAA,OAAAoB,KAAApB,EAAA,OAAAS,KAAAT,EAAA,OAAAW,KAAAX,EAAA,OAAAkB,KAEpDG,IAAA;EAAAR;EAAAK;EAAAT;EAAAE;EAAAS;EAMN,EAAApB,EAAA,KAAAa,GAAAb,EAAA,KAAAoB,GAAApB,EAAA,KAAAS,GAAAT,EAAA,KAAAW,GAAAX,EAAA,KAAAkB,GAAAlB,EAAA,MAAAqB,KAAAA,IAAArB,EAAA,KANMqB"}

package/dist/hooks/useSDK.d.ts

@@ -1,4 +1,4 @@
-import { LimitOrderHandlers, GetRateFunctions, APIVersion, GetDeltaOrdersFunctions, GetDeltaPriceFunctions, PostDeltaOrderFunctions, BuildDeltaOrderFunctions, SignDeltaOrderFunctions, PreSignDeltaOrderFunctions, CancelDeltaOrderFunctions, GetBridgeInfoFunctions, IsTokenSupportedInDeltaFunctions, BuildTxFunctions, GetSpenderFunctions, GetAdaptersFunctions, MinViemClient, GetLimitOrdersFunctions, BuildLimitOrderFunctions, PostLimitOrderFunctions, FillOrderDirectlyFunctions, DeltaTokenModuleFunctions, BuildTWAPDeltaOrderFunctions, PostTWAPDeltaOrderFunctions, PreSignTWAPDeltaOrderFunctions, SignTWAPDeltaOrderFunctions } from '@velora-dex/sdk';
+import { OTCOrderHandlers, GetRateFunctions, APIVersion, PreSignDeltaOrderFunctions, CancelDeltaOrderFunctions, IsTokenSupportedInDeltaFunctions, BuildTxFunctions, GetSpenderFunctions, GetAdaptersFunctions, MinViemClient, GetOTCOrdersFunctions, BuildOTCOrderFunctions, PostOTCOrderFunctions, FillOTCOrderFunctions, DeltaTokenModuleFunctions, PreSignTWAPDeltaOrderFunctions, GetBridgeRoutesFunctions, GetAgentsListFunctions, GetDeltaPriceFunctions, GetDeltaOrdersFunctions, BuildDeltaOrderFunctions, PostDeltaOrderFunctions, BuildTWAPDeltaOrderFunctions, PostTWAPDeltaOrderFunctions, SignDeltaOrderFunctions } from '@velora-dex/sdk';
 import { Address, Hash, Hex } from 'viem';
 import { Prettify } from 'ts-essentials';
 type SDKCreateParams = {
@@ -14,26 +14,26 @@ type ConstructedSDKOutput<T> = {
     apiURL: string;
 };
 export declare function useMarketSwapSDK({ chainId, apiURL, }: SDKCreateParams): ConstructedSDKOutput<MarketSwapSDK>;
-type LimitOrdersSDKCreateParams = SDKCreateParams & {
+type OTCOrdersSDKCreateParams = SDKCreateParams & {
     client?: MinViemClient;
 };
-type ReadOnlyLimitOrdersSDK = Prettify<GetLimitOrdersFunctions & BuildLimitOrderFunctions & PostLimitOrderFunctions>;
-export type LimitOrdersSDK = Prettify<LimitOrderHandlers<Hash>>;
-export declare function useLimitOrdersSDK({ chainId, apiURL, account, client, }: LimitOrdersSDKCreateParams & {
+type ReadOnlyOTCOrdersSDK = Prettify<GetOTCOrdersFunctions & BuildOTCOrderFunctions & PostOTCOrderFunctions>;
+export type OTCOrdersSDK = Prettify<OTCOrderHandlers<Hash>>;
+export declare function useOTCOrdersSDK({ chainId, apiURL, account, client, }: OTCOrdersSDKCreateParams & {
     account?: undefined;
     client?: undefined;
-}): ConstructedSDKOutput<ReadOnlyLimitOrdersSDK>;
-export declare function useLimitOrdersSDK({ chainId, apiURL, account, client, }: LimitOrdersSDKCreateParams & {
+}): ConstructedSDKOutput<ReadOnlyOTCOrdersSDK>;
+export declare function useOTCOrdersSDK({ chainId, apiURL, account, client, }: OTCOrdersSDKCreateParams & {
     account: Address;
     client: MinViemClient;
-}): ConstructedSDKOutput<LimitOrdersSDK>;
-export declare function useLimitOrdersSDK({ chainId, apiURL, account, client, }: LimitOrdersSDKCreateParams): ConstructedSDKOutput<LimitOrdersSDK | ReadOnlyLimitOrdersSDK>;
+}): ConstructedSDKOutput<OTCOrdersSDK>;
+export declare function useOTCOrdersSDK({ chainId, apiURL, account, client, }: OTCOrdersSDKCreateParams): ConstructedSDKOutput<OTCOrdersSDK | ReadOnlyOTCOrdersSDK>;
 export declare const useFetchOnlySDK: ({ chainId, apiURL, }: SDKCreateParams) => Partial<ConstructedSDKOutput<PostDeltaOrderFunctions>>;
-export declare const useCalldataSDK: ({ chainId, apiURL, client, }: Omit<LimitOrdersSDKCreateParams, "account">) => Partial<ConstructedSDKOutput<FillOrderDirectlyFunctions<Hex> & PreSignDeltaOrderFunctions<Hex> & BuildDeltaOrderFunctions & PreSignTWAPDeltaOrderFunctions<Hex> & BuildTWAPDeltaOrderFunctions>>;
-type ReadOnlyDeltaSDK = Prettify<GetDeltaOrdersFunctions & GetDeltaPriceFunctions & BuildDeltaOrderFunctions & PostDeltaOrderFunctions & BuildTWAPDeltaOrderFunctions & PostTWAPDeltaOrderFunctions & GetBridgeInfoFunctions & IsTokenSupportedInDeltaFunctions & {
+export declare const useCalldataSDK: ({ chainId, apiURL, client, }: Omit<OTCOrdersSDKCreateParams, "account">) => Partial<ConstructedSDKOutput<FillOTCOrderFunctions<Hex> & PreSignDeltaOrderFunctions<Hex> & BuildDeltaOrderFunctions & PreSignTWAPDeltaOrderFunctions<Hex> & BuildTWAPDeltaOrderFunctions>>;
+type ReadOnlyDeltaSDK = Prettify<GetDeltaPriceFunctions & GetDeltaOrdersFunctions & BuildDeltaOrderFunctions & PostDeltaOrderFunctions & BuildTWAPDeltaOrderFunctions & PostTWAPDeltaOrderFunctions & GetBridgeRoutesFunctions & IsTokenSupportedInDeltaFunctions & GetAgentsListFunctions & {
     chainId: number;
 }>;
-export type DeltaSDK = Prettify<ReadOnlyDeltaSDK & SignDeltaOrderFunctions & CancelDeltaOrderFunctions & PreSignDeltaOrderFunctions<Hash> & DeltaTokenModuleFunctions<Hash> & SignTWAPDeltaOrderFunctions & PreSignTWAPDeltaOrderFunctions<Hash>>;
+export type DeltaSDK = Prettify<ReadOnlyDeltaSDK & SignDeltaOrderFunctions & CancelDeltaOrderFunctions & PreSignDeltaOrderFunctions<Hash> & DeltaTokenModuleFunctions<Hash> & PreSignTWAPDeltaOrderFunctions<Hash>>;
 type DeltaSDKCreateParams = SDKCreateParams & {
     client?: MinViemClient;
 };

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

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

package/dist/hooks/useSDK.js

@@ -3,21 +3,21 @@ import { getApiURL as t } from "../lib/constants/urls.js";
 import { useApiConfig as n } from "../core/state/apiConfigAtom.js";
 import { useMemo as r } from "react";
 import i from "axios";
-import { constructAllLimitOrdersHandlers as a, constructAxiosFetcher as o, constructBuildDeltaOrder as s, constructBuildLimitOrder as c, constructBuildTWAPDeltaOrder as l, constructBuildTx as u, constructCancelDeltaOrder as d, constructDeltaTokenModule as f, constructFillOrderDirectly as p, constructGetAdapters as m, constructGetBridgeInfo as h, constructGetDeltaOrders as g, constructGetDeltaPrice as _, constructGetLimitOrders as v, constructGetRate as y, constructGetSpender as b, constructIsTokenSupportedInDelta as x, constructPartialSDK as S, constructPostDeltaOrder as C, constructPostLimitOrder as w, constructPostTWAPDeltaOrder as T, constructPreSignDeltaOrder as E, constructPreSignTWAPDeltaOrder as D, constructSignDeltaOrder as O, constructSignTWAPDeltaOrder as k, constructSubmitTWAPDeltaOrder as A, constructViemContractCaller as j } from "@velora-dex/sdk";
-import { encodeFunctionData as M } from "viem";
+import { constructAllOTCOrdersHandlers as a, constructAxiosFetcher as o, constructBuildDeltaOrder as s, constructBuildOTCOrder as c, constructBuildTWAPDeltaOrder as l, constructBuildTx as u, constructCancelDeltaOrder as d, constructDeltaTokenModule as f, constructFillOTCOrder as p, constructGetAdapters as m, constructGetAgentsList as h, constructGetBridgeRoutes as g, constructGetDeltaOrders as _, constructGetDeltaPrice as v, constructGetOTCOrders as y, constructGetRate as b, constructGetSpender as x, constructIsTokenSupportedInDelta as S, constructPartialSDK as C, constructPostDeltaOrder as w, constructPostOTCOrder as T, constructPostTWAPDeltaOrder as E, constructPreSignDeltaOrder as D, constructPreSignTWAPDeltaOrder as O, constructSignDeltaOrder as k, constructViemContractCaller as A } from "@velora-dex/sdk";
+import { encodeFunctionData as j } from "viem";
 //#region src/hooks/useSDK.ts
-function N() {
+function M() {
 	"use no memo";
 	let e = n();
 	return r(() => o(i, e), [e]);
 }
-function P({ chainId: e, apiURL: n }) {
+function N({ chainId: e, apiURL: n }) {
 	"use no memo";
-	let i = N(), a = r(() => S({
+	let i = M(), a = r(() => C({
 		apiURL: n ?? t(),
 		chainId: e,
 		fetcher: i
-	}, y, b, m, u), [
+	}, b, x, m, u), [
 		n,
 		e,
 		i
@@ -29,19 +29,19 @@ function P({ chainId: e, apiURL: n }) {
 		sdk: a
 	};
 }
-var F = e("LimitOrdersSDK");
-function I({ chainId: e, apiURL: n, account: i, client: o }) {
+var P = e("OTCOrdersSDK");
+function F({ chainId: e, apiURL: n, account: i, client: o }) {
 	"use no memo";
-	let s = N(), l = r(() => {
-		F.once.log("init sdk");
+	let s = M(), l = r(() => {
+		P.once.log("init sdk");
 		let r = {
 			apiURL: n ?? t(),
 			chainId: e,
 			fetcher: s
 		};
-		if (!o || !i) return S(r, v, c, w);
-		let l = j(o, i);
-		return S({
+		if (!o || !i) return C(r, y, c, T);
+		let l = A(o, i);
+		return C({
 			...r,
 			contractCaller: l
 		}, a);
@@ -59,10 +59,10 @@ function I({ chainId: e, apiURL: n, account: i, client: o }) {
 		sdk: l
 	};
 }
-var L = () => {
+var I = () => {
 	let e = async (e) => {
 		let { abi: t, contractMethod: n, args: r } = e;
-		return M({
+		return j({
 			abi: t,
 			functionName: n,
 			args: r
@@ -75,18 +75,18 @@ var L = () => {
 		staticCall: t,
 		signTypedDataCall: t
 	};
-}, R = e("CalldataSDK"), z = ({ chainId: e, apiURL: n, client: i }) => {
+}, L = e("CalldataSDK"), R = ({ chainId: e, apiURL: n, client: i }) => {
 	"use no memo";
-	let a = N(), o = r(() => {
+	let a = M(), o = r(() => {
 		if (!i) return;
-		R.once.log("init sdk");
-		let r = L();
-		return S({
+		L.once.log("init sdk");
+		let r = I();
+		return C({
 			apiURL: n ?? t(),
 			chainId: e,
 			fetcher: a,
 			contractCaller: r
-		}, p, E, s, D, l);
+		}, p, D, s, O, l);
 	}, [
 		n,
 		e,
@@ -99,22 +99,22 @@ var L = () => {
 		apiURL: o?.apiURL,
 		sdk: o
 	};
-}, B = e("DeltaSDK");
-function V({ chainId: e, apiURL: n, account: i, client: a }) {
+}, z = e("DeltaSDK");
+function B({ chainId: e, apiURL: n, account: i, client: a }) {
 	"use no memo";
-	let o = N(), c = r(() => {
-		B.once.log("init sdk");
+	let o = M(), c = r(() => {
+		z.once.log("init sdk");
 		let r = {
 			apiURL: n ?? t(),
 			chainId: e,
 			fetcher: o
 		};
-		if (!a || !i) return S(r, g, _, s, C, l, T, h, x);
-		let c = j(a, i);
-		return S({
+		if (!a || !i) return C(r, v, _, s, w, l, E, g, S, h);
+		let c = A(a, i);
+		return C({
 			...r,
 			contractCaller: c
-		}, g, _, s, C, d, h, x, O, E, T, l, k, D, A, f);
+		}, v, _, s, w, l, E, g, S, h, k, d, D, O, f);
 	}, [
 		n,
 		e,
@@ -130,6 +130,6 @@ function V({ chainId: e, apiURL: n, account: i, client: a }) {
 	};
 }
 //#endregion
-export { z as useCalldataSDK, V as useDeltaSDK, I as useLimitOrdersSDK, P as useMarketSwapSDK };
+export { R as useCalldataSDK, B as useDeltaSDK, N as useMarketSwapSDK, F as useOTCOrdersSDK };
 
 //# sourceMappingURL=useSDK.js.map

package/dist/hooks/useSDK.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSDK.js","names":["axios","useMemo","constructAxiosFetcher","constructFetchFetcher","constructPartialSDK","constructGetSpender","constructGetAdapters","constructBuildTx","constructAllLimitOrdersHandlers","constructGetRate","constructGetDeltaPrice","constructGetDeltaOrders","constructBuildDeltaOrder","constructSignDeltaOrder","constructPreSignDeltaOrder","constructPostDeltaOrder","constructCancelDeltaOrder","constructGetBridgeInfo","constructIsTokenSupportedInDelta","constructDeltaTokenModule","constructViemContractCaller","LimitOrderHandlers","GetRateFunctions","APIVersion","GetDeltaOrdersFunctions","GetDeltaPriceFunctions","PostDeltaOrderFunctions","BuildDeltaOrderFunctions","SignDeltaOrderFunctions","PreSignDeltaOrderFunctions","CancelDeltaOrderFunctions","GetBridgeInfoFunctions","IsTokenSupportedInDeltaFunctions","BuildTxFunctions","GetSpenderFunctions","GetAdaptersFunctions","MinViemClient","constructGetLimitOrders","constructBuildLimitOrder","constructPostLimitOrder","constructFillOrderDirectly","GetLimitOrdersFunctions","BuildLimitOrderFunctions","PostLimitOrderFunctions","FillOrderDirectlyFunctions","ContractCallerFunctions","DeltaTokenModuleFunctions","BuildTWAPDeltaOrderFunctions","PostTWAPDeltaOrderFunctions","constructPreSignTWAPDeltaOrder","constructBuildTWAPDeltaOrder","PreSignTWAPDeltaOrderFunctions","constructPostTWAPDeltaOrder","constructSignTWAPDeltaOrder","constructSubmitTWAPDeltaOrder","SignTWAPDeltaOrderFunctions","encodeFunctionData","Address","Hash","Hex","Prettify","getLogger","getApiURL","useApiConfig","useSDKFetcher","apiConfig","useKeepAliveSDKFetcher","window","fetch","keepalive","SDKCreateParams","chainId","apiURL","account","MarketSwapSDK","ConstructedSDKOutput","sdk","T","appVersion","useMarketSwapSDK","fetcher","SDKconfig","version","LimitOrdersSDKCreateParams","client","ReadOnlyLimitOrdersSDK","LimitOrdersSDK","limitSDKLogger","useLimitOrdersSDK","once","log","contractCaller","CalldataContractCaller","constructCalldataContractCaller","transactCall","params","abi","contractMethod","functionName","args","calldata","staticCall","Error","signTypedDataCall","useFetchOnlySDK","Partial","calldataSDKLogger","useCalldataSDK","Omit","ReadOnlyDeltaSDK","DeltaSDK","DeltaSDKCreateParams","deltaSDKLogger","useDeltaSDK"],"sources":["../../src/hooks/useSDK.ts"],"sourcesContent":["import axios from \"axios\";\nimport { useMemo } from \"react\";\n\nimport {\n  constructAxiosFetcher,\n  constructFetchFetcher,\n  constructPartialSDK,\n  constructGetSpender,\n  constructGetAdapters,\n  constructBuildTx,\n  constructAllLimitOrdersHandlers,\n  constructGetRate,\n  constructGetDeltaPrice,\n  constructGetDeltaOrders,\n  constructBuildDeltaOrder,\n  constructSignDeltaOrder,\n  constructPreSignDeltaOrder,\n  constructPostDeltaOrder,\n  constructCancelDeltaOrder,\n  constructGetBridgeInfo,\n  constructIsTokenSupportedInDelta,\n  constructDeltaTokenModule,\n  constructViemContractCaller,\n  type LimitOrderHandlers,\n  type GetRateFunctions,\n  type APIVersion,\n  type GetDeltaOrdersFunctions,\n  type GetDeltaPriceFunctions,\n  type PostDeltaOrderFunctions,\n  type BuildDeltaOrderFunctions,\n  type SignDeltaOrderFunctions,\n  type PreSignDeltaOrderFunctions,\n  type CancelDeltaOrderFunctions,\n  type GetBridgeInfoFunctions,\n  type IsTokenSupportedInDeltaFunctions,\n  type BuildTxFunctions,\n  type GetSpenderFunctions,\n  type GetAdaptersFunctions,\n  type MinViemClient,\n  constructGetLimitOrders,\n  constructBuildLimitOrder,\n  constructPostLimitOrder,\n  constructFillOrderDirectly,\n  type GetLimitOrdersFunctions,\n  type BuildLimitOrderFunctions,\n  type PostLimitOrderFunctions,\n  type FillOrderDirectlyFunctions,\n  type ContractCallerFunctions,\n  type DeltaTokenModuleFunctions,\n  type BuildTWAPDeltaOrderFunctions,\n  type PostTWAPDeltaOrderFunctions,\n  constructPreSignTWAPDeltaOrder,\n  constructBuildTWAPDeltaOrder,\n  type PreSignTWAPDeltaOrderFunctions,\n  constructPostTWAPDeltaOrder,\n  constructSignTWAPDeltaOrder,\n  constructSubmitTWAPDeltaOrder,\n  type SignTWAPDeltaOrderFunctions,\n} from \"@velora-dex/sdk\";\nimport { encodeFunctionData, type Address, type Hash, type Hex } from \"viem\";\nimport type { Prettify } from \"ts-essentials\";\nimport { getLogger } from \"@/core/logger\";\nimport { getApiURL } from \"@/lib/constants/urls\";\nimport { useApiConfig } from \"@/core/state/apiConfigAtom\";\n\nfunction useSDKFetcher() {\n  \"use no memo\";\n\n  const apiConfig = useApiConfig();\n\n  return useMemo(() => {\n    return constructAxiosFetcher(axios, apiConfig);\n  }, [apiConfig]);\n}\n\nfunction useKeepAliveSDKFetcher() {\n  \"use no memo\";\n\n  const apiConfig = useApiConfig();\n\n  return useMemo(() => {\n    if (typeof window === \"undefined\") return;\n    return constructFetchFetcher(window.fetch, {\n      ...apiConfig,\n      keepalive: true,\n    });\n  }, [apiConfig]);\n}\n\ntype SDKCreateParams = {\n  chainId: number;\n  apiURL?: string;\n  account?: Address;\n};\n\nexport type MarketSwapSDK = Prettify<\n  GetSpenderFunctions &\n    BuildTxFunctions &\n    GetRateFunctions &\n    GetAdaptersFunctions\n>;\n\ntype ConstructedSDKOutput<T> = {\n  sdk: T;\n  appVersion: APIVersion;\n  chainId: number;\n  apiURL: string;\n};\n\nexport function useMarketSwapSDK({\n  chainId,\n  apiURL,\n}: SDKCreateParams): ConstructedSDKOutput<MarketSwapSDK> {\n  \"use no memo\";\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n    };\n\n    return constructPartialSDK(\n      SDKconfig,\n      constructGetRate,\n      constructGetSpender,\n      constructGetAdapters,\n      constructBuildTx\n    );\n  }, [apiURL, chainId, fetcher]);\n\n  return {\n    appVersion: sdk.version,\n    chainId: sdk.chainId,\n    apiURL: sdk.apiURL,\n    sdk,\n  };\n}\ntype LimitOrdersSDKCreateParams = SDKCreateParams & {\n  client?: MinViemClient;\n};\n\ntype ReadOnlyLimitOrdersSDK = Prettify<\n  GetLimitOrdersFunctions & BuildLimitOrderFunctions & PostLimitOrderFunctions\n>;\n\nexport type LimitOrdersSDK = Prettify<LimitOrderHandlers<Hash>>;\n\nconst limitSDKLogger = getLogger(\"LimitOrdersSDK\");\n\n// can paraswap.fillOrder from a taker address to simulate happy path\n// @TODO check that we always use correct SDK version\nexport function useLimitOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: LimitOrdersSDKCreateParams & {\n  account?: undefined;\n  client?: undefined;\n}): ConstructedSDKOutput<ReadOnlyLimitOrdersSDK>;\nexport function useLimitOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: LimitOrdersSDKCreateParams & {\n  account: Address;\n  client: MinViemClient;\n}): ConstructedSDKOutput<LimitOrdersSDK>;\nexport function useLimitOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: LimitOrdersSDKCreateParams): ConstructedSDKOutput<\n  LimitOrdersSDK | ReadOnlyLimitOrdersSDK\n>;\nexport function useLimitOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: LimitOrdersSDKCreateParams): ConstructedSDKOutput<\n  LimitOrdersSDK | ReadOnlyLimitOrdersSDK\n> {\n  \"use no memo\";\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    limitSDKLogger.once.log(\"init sdk\");\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n    };\n\n    if (!client || !account) {\n      return constructPartialSDK(\n        SDKconfig,\n        constructGetLimitOrders,\n        constructBuildLimitOrder,\n        constructPostLimitOrder\n      );\n    }\n\n    const contractCaller = constructViemContractCaller(client, account);\n\n    return constructPartialSDK(\n      { ...SDKconfig, contractCaller },\n      constructAllLimitOrdersHandlers\n    );\n  }, [client, account, apiURL, chainId, fetcher]);\n\n  return {\n    appVersion: sdk.version,\n    chainId: sdk.chainId,\n    apiURL: sdk.apiURL,\n    sdk,\n  };\n}\n\n// ContractCaller that returns Contract[method](args) calldata instead of sending out a transaction\ntype CalldataContractCaller = ContractCallerFunctions<Hex>;\n\nconst constructCalldataContractCaller = (): CalldataContractCaller => {\n  const transactCall: CalldataContractCaller[\"transactCall\"] = async (\n    params\n  ) => {\n    const { abi, contractMethod: functionName, args } = params;\n    const calldata = encodeFunctionData<typeof abi, string>({\n      abi,\n      functionName,\n      args,\n    });\n    return calldata;\n  };\n\n  // won't be used, but needed for types\n  const staticCall = () => {\n    throw new Error(\"Not implemented\");\n  };\n\n  return {\n    transactCall,\n    staticCall,\n    signTypedDataCall: staticCall,\n  };\n};\n\n// can be used to POST final data before page is closed\nexport const useFetchOnlySDK = ({\n  chainId,\n  apiURL,\n}: SDKCreateParams): Partial<ConstructedSDKOutput<PostDeltaOrderFunctions>> => {\n  \"use no memo\";\n\n  // fetch, unlike axios allows for `keepalive` parameter,\n  // so we can use it to keep the request alive a bit after the page is closed.\n  // the alternative of using navigator.sendBeacon doesn't work with API because it includes credentials=always\n  // which is incompatible with API CORS settings\n  const fetcher = useKeepAliveSDKFetcher();\n\n  const sdk = useMemo(() => {\n    if (!fetcher) return;\n\n    return constructPartialSDK(\n      {\n        apiURL: apiURL ?? getApiURL(),\n        chainId,\n        fetcher,\n      },\n      constructPostDeltaOrder\n    );\n  }, [apiURL, chainId, fetcher]);\n\n  return {\n    appVersion: sdk?.version,\n    chainId: sdk?.chainId,\n    apiURL: sdk?.apiURL,\n    sdk,\n  };\n};\n\nconst calldataSDKLogger = getLogger(\"CalldataSDK\");\n\nexport const useCalldataSDK = ({\n  chainId,\n  apiURL,\n  client,\n}: Omit<LimitOrdersSDKCreateParams, \"account\">): Partial<\n  ConstructedSDKOutput<\n    FillOrderDirectlyFunctions<Hex> &\n      PreSignDeltaOrderFunctions<Hex> &\n      BuildDeltaOrderFunctions &\n      PreSignTWAPDeltaOrderFunctions<Hex> &\n      BuildTWAPDeltaOrderFunctions\n  >\n> => {\n  \"use no memo\";\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    if (!client) return;\n    calldataSDKLogger.once.log(\"init sdk\");\n\n    const contractCaller = constructCalldataContractCaller();\n\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n      contractCaller,\n    };\n\n    return constructPartialSDK(\n      SDKconfig,\n      constructFillOrderDirectly,\n      constructPreSignDeltaOrder,\n      constructBuildDeltaOrder,\n      constructPreSignTWAPDeltaOrder,\n      constructBuildTWAPDeltaOrder\n    );\n  }, [apiURL, chainId, client, fetcher]);\n\n  return {\n    appVersion: sdk?.version,\n    chainId: sdk?.chainId,\n    apiURL: sdk?.apiURL,\n    sdk,\n  };\n};\n\ntype ReadOnlyDeltaSDK = Prettify<\n  GetDeltaOrdersFunctions &\n    GetDeltaPriceFunctions &\n    BuildDeltaOrderFunctions &\n    PostDeltaOrderFunctions &\n    BuildTWAPDeltaOrderFunctions &\n    PostTWAPDeltaOrderFunctions &\n    GetBridgeInfoFunctions &\n    IsTokenSupportedInDeltaFunctions & { chainId: number }\n>;\n\nexport type DeltaSDK = Prettify<\n  ReadOnlyDeltaSDK &\n    SignDeltaOrderFunctions &\n    CancelDeltaOrderFunctions &\n    PreSignDeltaOrderFunctions<Hash> &\n    DeltaTokenModuleFunctions<Hash> &\n    SignTWAPDeltaOrderFunctions &\n    PreSignTWAPDeltaOrderFunctions<Hash>\n>;\n\ntype DeltaSDKCreateParams = SDKCreateParams & {\n  client?: MinViemClient;\n};\n\nconst deltaSDKLogger = getLogger(\"DeltaSDK\");\n\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams & {\n  account?: undefined;\n  client?: undefined;\n}): ConstructedSDKOutput<ReadOnlyDeltaSDK>;\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams & {\n  account: Address;\n  client: MinViemClient;\n}): ConstructedSDKOutput<DeltaSDK>;\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams): ConstructedSDKOutput<DeltaSDK | ReadOnlyDeltaSDK>;\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams): ConstructedSDKOutput<DeltaSDK | ReadOnlyDeltaSDK> {\n  \"use no memo\";\n  // react-compiler fails here and sdk is created anew\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    deltaSDKLogger.once.log(\"init sdk\");\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n    };\n\n    if (!client || !account) {\n      return constructPartialSDK(\n        SDKconfig,\n        constructGetDeltaOrders,\n        constructGetDeltaPrice,\n        constructBuildDeltaOrder,\n        constructPostDeltaOrder,\n        constructBuildTWAPDeltaOrder,\n        constructPostTWAPDeltaOrder,\n        constructGetBridgeInfo,\n        constructIsTokenSupportedInDelta\n      );\n    }\n\n    const contractCaller = constructViemContractCaller(client, account);\n\n    return constructPartialSDK(\n      { ...SDKconfig, contractCaller },\n      constructGetDeltaOrders,\n      constructGetDeltaPrice,\n      constructBuildDeltaOrder,\n      constructPostDeltaOrder,\n      constructCancelDeltaOrder,\n      constructGetBridgeInfo,\n      constructIsTokenSupportedInDelta,\n      constructSignDeltaOrder,\n      constructPreSignDeltaOrder,\n      constructPostTWAPDeltaOrder,\n      constructBuildTWAPDeltaOrder,\n      constructSignTWAPDeltaOrder,\n      constructPreSignTWAPDeltaOrder,\n      constructSubmitTWAPDeltaOrder,\n      constructDeltaTokenModule\n    );\n  }, [apiURL, chainId, client, account, fetcher]);\n\n  return {\n    appVersion: sdk.version,\n    chainId: sdk.chainId,\n    apiURL: sdk.apiURL,\n    sdk,\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"useSDK.js","names":["axios","useMemo","constructAxiosFetcher","constructFetchFetcher","constructPartialSDK","constructGetSpender","constructGetAdapters","constructBuildTx","constructAllOTCOrdersHandlers","constructGetRate","constructPreSignDeltaOrder","constructPostDeltaOrder","constructCancelDeltaOrder","constructIsTokenSupportedInDelta","constructDeltaTokenModule","constructViemContractCaller","OTCOrderHandlers","GetRateFunctions","APIVersion","PreSignDeltaOrderFunctions","CancelDeltaOrderFunctions","IsTokenSupportedInDeltaFunctions","BuildTxFunctions","GetSpenderFunctions","GetAdaptersFunctions","MinViemClient","constructGetOTCOrders","constructBuildOTCOrder","constructPostOTCOrder","constructFillOTCOrder","GetOTCOrdersFunctions","BuildOTCOrderFunctions","PostOTCOrderFunctions","FillOTCOrderFunctions","ContractCallerFunctions","DeltaTokenModuleFunctions","constructPreSignTWAPDeltaOrder","PreSignTWAPDeltaOrderFunctions","constructPostTWAPDeltaOrder","GetBridgeRoutesFunctions","GetAgentsListFunctions","constructGetBridgeRoutes","constructGetAgentsList","GetDeltaPriceFunctions","GetDeltaOrdersFunctions","BuildDeltaOrderFunctions","PostDeltaOrderFunctions","BuildTWAPDeltaOrderFunctions","PostTWAPDeltaOrderFunctions","SignDeltaOrderFunctions","constructGetDeltaPrice","constructGetDeltaOrders","constructBuildDeltaOrder","constructBuildTWAPDeltaOrder","constructSignDeltaOrder","encodeFunctionData","Address","Hash","Hex","Prettify","getLogger","getApiURL","useApiConfig","useSDKFetcher","apiConfig","useKeepAliveSDKFetcher","window","fetch","keepalive","SDKCreateParams","chainId","apiURL","account","MarketSwapSDK","ConstructedSDKOutput","sdk","T","appVersion","useMarketSwapSDK","fetcher","SDKconfig","version","OTCOrdersSDKCreateParams","client","ReadOnlyOTCOrdersSDK","OTCOrdersSDK","otcSDKLogger","useOTCOrdersSDK","once","log","contractCaller","CalldataContractCaller","constructCalldataContractCaller","transactCall","params","abi","contractMethod","functionName","args","calldata","staticCall","Error","signTypedDataCall","useFetchOnlySDK","Partial","calldataSDKLogger","useCalldataSDK","Omit","ReadOnlyDeltaSDK","DeltaSDK","DeltaSDKCreateParams","deltaSDKLogger","useDeltaSDK"],"sources":["../../src/hooks/useSDK.ts"],"sourcesContent":["import axios from \"axios\";\nimport { useMemo } from \"react\";\n\nimport {\n  constructAxiosFetcher,\n  constructFetchFetcher,\n  constructPartialSDK,\n  constructGetSpender,\n  constructGetAdapters,\n  constructBuildTx,\n  constructAllOTCOrdersHandlers,\n  constructGetRate,\n  constructPreSignDeltaOrder,\n  constructPostDeltaOrder,\n  constructCancelDeltaOrder,\n  constructIsTokenSupportedInDelta,\n  constructDeltaTokenModule,\n  constructViemContractCaller,\n  type OTCOrderHandlers,\n  type GetRateFunctions,\n  type APIVersion,\n  type PreSignDeltaOrderFunctions,\n  type CancelDeltaOrderFunctions,\n  type IsTokenSupportedInDeltaFunctions,\n  type BuildTxFunctions,\n  type GetSpenderFunctions,\n  type GetAdaptersFunctions,\n  type MinViemClient,\n  constructGetOTCOrders,\n  constructBuildOTCOrder,\n  constructPostOTCOrder,\n  constructFillOTCOrder,\n  type GetOTCOrdersFunctions,\n  type BuildOTCOrderFunctions,\n  type PostOTCOrderFunctions,\n  type FillOTCOrderFunctions,\n  type ContractCallerFunctions,\n  type DeltaTokenModuleFunctions,\n  constructPreSignTWAPDeltaOrder,\n  type PreSignTWAPDeltaOrderFunctions,\n  constructPostTWAPDeltaOrder,\n  type GetBridgeRoutesFunctions,\n  type GetAgentsListFunctions,\n  constructGetBridgeRoutes,\n  constructGetAgentsList,\n  type GetDeltaPriceFunctions,\n  type GetDeltaOrdersFunctions,\n  type BuildDeltaOrderFunctions,\n  type PostDeltaOrderFunctions,\n  type BuildTWAPDeltaOrderFunctions,\n  type PostTWAPDeltaOrderFunctions,\n  type SignDeltaOrderFunctions,\n  constructGetDeltaPrice,\n  constructGetDeltaOrders,\n  constructBuildDeltaOrder,\n  constructBuildTWAPDeltaOrder,\n  constructSignDeltaOrder,\n} from \"@velora-dex/sdk\";\nimport { encodeFunctionData, type Address, type Hash, type Hex } from \"viem\";\nimport type { Prettify } from \"ts-essentials\";\nimport { getLogger } from \"@/core/logger\";\nimport { getApiURL } from \"@/lib/constants/urls\";\nimport { useApiConfig } from \"@/core/state/apiConfigAtom\";\n\nfunction useSDKFetcher() {\n  \"use no memo\";\n\n  const apiConfig = useApiConfig();\n\n  return useMemo(() => {\n    return constructAxiosFetcher(axios, apiConfig);\n  }, [apiConfig]);\n}\n\nfunction useKeepAliveSDKFetcher() {\n  \"use no memo\";\n\n  const apiConfig = useApiConfig();\n\n  return useMemo(() => {\n    if (typeof window === \"undefined\") return;\n    return constructFetchFetcher(window.fetch, {\n      ...apiConfig,\n      keepalive: true,\n    });\n  }, [apiConfig]);\n}\n\ntype SDKCreateParams = {\n  chainId: number;\n  apiURL?: string;\n  account?: Address;\n};\n\nexport type MarketSwapSDK = Prettify<\n  GetSpenderFunctions &\n  BuildTxFunctions &\n  GetRateFunctions &\n  GetAdaptersFunctions\n>;\n\ntype ConstructedSDKOutput<T> = {\n  sdk: T;\n  appVersion: APIVersion;\n  chainId: number;\n  apiURL: string;\n};\n\nexport function useMarketSwapSDK({\n  chainId,\n  apiURL,\n}: SDKCreateParams): ConstructedSDKOutput<MarketSwapSDK> {\n  \"use no memo\";\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n    };\n\n    return constructPartialSDK(\n      SDKconfig,\n      constructGetRate,\n      constructGetSpender,\n      constructGetAdapters,\n      constructBuildTx\n    );\n  }, [apiURL, chainId, fetcher]);\n\n  return {\n    appVersion: sdk.version,\n    chainId: sdk.chainId,\n    apiURL: sdk.apiURL,\n    sdk,\n  };\n}\ntype OTCOrdersSDKCreateParams = SDKCreateParams & {\n  client?: MinViemClient;\n};\n\ntype ReadOnlyOTCOrdersSDK = Prettify<\n  GetOTCOrdersFunctions & BuildOTCOrderFunctions & PostOTCOrderFunctions\n>;\n\nexport type OTCOrdersSDK = Prettify<OTCOrderHandlers<Hash>>;\n\nconst otcSDKLogger = getLogger(\"OTCOrdersSDK\");\n\n// can paraswap.fillOrder from a taker address to simulate happy path\n// @TODO check that we always use correct SDK version\nexport function useOTCOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: OTCOrdersSDKCreateParams & {\n  account?: undefined;\n  client?: undefined;\n}): ConstructedSDKOutput<ReadOnlyOTCOrdersSDK>;\nexport function useOTCOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: OTCOrdersSDKCreateParams & {\n  account: Address;\n  client: MinViemClient;\n}): ConstructedSDKOutput<OTCOrdersSDK>;\nexport function useOTCOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: OTCOrdersSDKCreateParams): ConstructedSDKOutput<\n  OTCOrdersSDK | ReadOnlyOTCOrdersSDK\n>;\nexport function useOTCOrdersSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: OTCOrdersSDKCreateParams): ConstructedSDKOutput<\n  OTCOrdersSDK | ReadOnlyOTCOrdersSDK\n> {\n  \"use no memo\";\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    otcSDKLogger.once.log(\"init sdk\");\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n    };\n\n    if (!client || !account) {\n      return constructPartialSDK(\n        SDKconfig,\n        constructGetOTCOrders,\n        constructBuildOTCOrder,\n        constructPostOTCOrder\n      );\n    }\n\n    const contractCaller = constructViemContractCaller(client, account);\n\n    return constructPartialSDK(\n      { ...SDKconfig, contractCaller },\n      constructAllOTCOrdersHandlers\n    );\n  }, [client, account, apiURL, chainId, fetcher]);\n\n  return {\n    appVersion: sdk.version,\n    chainId: sdk.chainId,\n    apiURL: sdk.apiURL,\n    sdk,\n  };\n}\n\n// ContractCaller that returns Contract[method](args) calldata instead of sending out a transaction\ntype CalldataContractCaller = ContractCallerFunctions<Hex>;\n\nconst constructCalldataContractCaller = (): CalldataContractCaller => {\n  const transactCall: CalldataContractCaller[\"transactCall\"] = async (\n    params\n  ) => {\n    const { abi, contractMethod: functionName, args } = params;\n    const calldata = encodeFunctionData<typeof abi, string>({\n      abi,\n      functionName,\n      args,\n    });\n    return calldata;\n  };\n\n  // won't be used, but needed for types\n  const staticCall = () => {\n    throw new Error(\"Not implemented\");\n  };\n\n  return {\n    transactCall,\n    staticCall,\n    signTypedDataCall: staticCall,\n  };\n};\n\n// can be used to POST final data before page is closed\nexport const useFetchOnlySDK = ({\n  chainId,\n  apiURL,\n}: SDKCreateParams): Partial<\n  ConstructedSDKOutput<PostDeltaOrderFunctions>\n> => {\n  \"use no memo\";\n\n  // fetch, unlike axios allows for `keepalive` parameter,\n  // so we can use it to keep the request alive a bit after the page is closed.\n  // the alternative of using navigator.sendBeacon doesn't work with API because it includes credentials=always\n  // which is incompatible with API CORS settings\n  const fetcher = useKeepAliveSDKFetcher();\n\n  const sdk = useMemo(() => {\n    if (!fetcher) return;\n\n    return constructPartialSDK(\n      {\n        apiURL: apiURL ?? getApiURL(),\n        chainId,\n        fetcher,\n      },\n      constructPostDeltaOrder\n    );\n  }, [apiURL, chainId, fetcher]);\n\n  return {\n    appVersion: sdk?.version,\n    chainId: sdk?.chainId,\n    apiURL: sdk?.apiURL,\n    sdk,\n  };\n};\n\nconst calldataSDKLogger = getLogger(\"CalldataSDK\");\n\nexport const useCalldataSDK = ({\n  chainId,\n  apiURL,\n  client,\n}: Omit<OTCOrdersSDKCreateParams, \"account\">): Partial<\n  ConstructedSDKOutput<\n    FillOTCOrderFunctions<Hex> &\n    PreSignDeltaOrderFunctions<Hex> &\n    BuildDeltaOrderFunctions &\n    PreSignTWAPDeltaOrderFunctions<Hex> &\n    BuildTWAPDeltaOrderFunctions\n  >\n> => {\n  \"use no memo\";\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    if (!client) return;\n    calldataSDKLogger.once.log(\"init sdk\");\n\n    const contractCaller = constructCalldataContractCaller();\n\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n      contractCaller,\n    };\n\n    return constructPartialSDK(\n      SDKconfig,\n      constructFillOTCOrder,\n      constructPreSignDeltaOrder,\n      constructBuildDeltaOrder,\n      constructPreSignTWAPDeltaOrder,\n      constructBuildTWAPDeltaOrder\n    );\n  }, [apiURL, chainId, client, fetcher]);\n\n  return {\n    appVersion: sdk?.version,\n    chainId: sdk?.chainId,\n    apiURL: sdk?.apiURL,\n    sdk,\n  };\n};\n\ntype ReadOnlyDeltaSDK = Prettify<\n  GetDeltaPriceFunctions &\n  GetDeltaOrdersFunctions &\n  BuildDeltaOrderFunctions &\n  PostDeltaOrderFunctions &\n  BuildTWAPDeltaOrderFunctions &\n  PostTWAPDeltaOrderFunctions &\n  GetBridgeRoutesFunctions &\n  IsTokenSupportedInDeltaFunctions &\n  GetAgentsListFunctions & { chainId: number }\n>;\n\nexport type DeltaSDK = Prettify<\n  ReadOnlyDeltaSDK &\n  SignDeltaOrderFunctions &\n  CancelDeltaOrderFunctions &\n  PreSignDeltaOrderFunctions<Hash> &\n  DeltaTokenModuleFunctions<Hash> &\n  PreSignTWAPDeltaOrderFunctions<Hash>\n>;\n\ntype DeltaSDKCreateParams = SDKCreateParams & {\n  client?: MinViemClient;\n};\n\nconst deltaSDKLogger = getLogger(\"DeltaSDK\");\n\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams & {\n  account?: undefined;\n  client?: undefined;\n}): ConstructedSDKOutput<ReadOnlyDeltaSDK>;\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams & {\n  account: Address;\n  client: MinViemClient;\n}): ConstructedSDKOutput<DeltaSDK>;\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams): ConstructedSDKOutput<\n  DeltaSDK | ReadOnlyDeltaSDK\n>;\nexport function useDeltaSDK({\n  chainId,\n  apiURL,\n  account,\n  client,\n}: DeltaSDKCreateParams): ConstructedSDKOutput<\n  DeltaSDK | ReadOnlyDeltaSDK\n> {\n  \"use no memo\";\n\n  const fetcher = useSDKFetcher();\n\n  const sdk = useMemo(() => {\n    deltaSDKLogger.once.log(\"init sdk\");\n    const SDKconfig = {\n      apiURL: apiURL ?? getApiURL(),\n      chainId,\n      fetcher,\n    };\n\n    if (!client || !account) {\n      return constructPartialSDK(\n        SDKconfig,\n        constructGetDeltaPrice,\n        constructGetDeltaOrders,\n        constructBuildDeltaOrder,\n        constructPostDeltaOrder,\n        constructBuildTWAPDeltaOrder,\n        constructPostTWAPDeltaOrder,\n        constructGetBridgeRoutes,\n        constructIsTokenSupportedInDelta,\n        constructGetAgentsList\n      );\n    }\n\n    const contractCaller = constructViemContractCaller(client, account);\n\n    return constructPartialSDK(\n      { ...SDKconfig, contractCaller },\n      constructGetDeltaPrice,\n      constructGetDeltaOrders,\n      constructBuildDeltaOrder,\n      constructPostDeltaOrder,\n      constructBuildTWAPDeltaOrder,\n      constructPostTWAPDeltaOrder,\n      constructGetBridgeRoutes,\n      constructIsTokenSupportedInDelta,\n      constructGetAgentsList,\n      constructSignDeltaOrder,\n      constructCancelDeltaOrder,\n      constructPreSignDeltaOrder,\n      constructPreSignTWAPDeltaOrder,\n      constructDeltaTokenModule\n    );\n  }, [apiURL, chainId, client, account, fetcher]);\n\n  return {\n    appVersion: sdk.version,\n    chainId: sdk.chainId,\n    apiURL: sdk.apiURL,\n    sdk,\n  };\n}\n"],"mappings":"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"}

package/dist/hooks/useSelectableDestChains.d.ts

@@ -1,9 +1,9 @@
 import { SupportedChainId } from '../lib/web3/wagmi/types';
 import { NonEmptyArray } from 'ts-essentials';
-import { BridgeInfoMode } from './swap/prices/delta/queries/bridgeInfo/types';
+import { BridgeRoutesMode } from './swap/prices/delta/queries/bridgeInfo/types';
 export declare function useSelectableDestChains({ fromChainId, mode, }: {
     fromChainId: SupportedChainId;
-    mode: BridgeInfoMode;
+    mode: BridgeRoutesMode;
 }): {
     selectableChains: SupportedChainId[];
     isChainSelectable: (chain: SupportedChainId) => boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"useSelectableDestChains.d.ts","sourceRoot":"","sources":["../../src/hooks/useSelectableDestChains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAM/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8CAA8C,CAAC;AAEnF,wBAAgB,uBAAuB,CAAC,EACtC,WAAW,EACX,IAAI,GACL,EAAE;IACD,WAAW,EAAE,gBAAgB,CAAC;IAC9B,IAAI,EAAE,cAAc,CAAC;CACtB,GAAG;IACF,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;IACrC,iBAAiB,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC;CACzD,CAqBA;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,GACZ,EAAE;IACD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,iBAAiB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACnD,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;IACrC,WAAW,EAAE,gBAAgB,CAAC;CAC/B,4DAiBA"}
+{"version":3,"file":"useSelectableDestChains.d.ts","sourceRoot":"","sources":["../../src/hooks/useSelectableDestChains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAM/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAErF,wBAAgB,uBAAuB,CAAC,EACtC,WAAW,EACX,IAAI,GACL,EAAE;IACD,WAAW,EAAE,gBAAgB,CAAC;IAC9B,IAAI,EAAE,gBAAgB,CAAC;CACxB,GAAG;IACF,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;IACrC,iBAAiB,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC;CACzD,CAqBA;AAED,wBAAgB,2BAA2B,CAAC,EAC1C,gBAAgB,EAChB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,GACZ,EAAE;IACD,gBAAgB,EAAE,OAAO,CAAC;IAC1B,oBAAoB,EAAE,OAAO,CAAC;IAC9B,iBAAiB,EAAE,aAAa,CAAC,gBAAgB,CAAC,CAAC;IACnD,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;IACrC,WAAW,EAAE,gBAAgB,CAAC;CAC/B,4DAiBA"}

package/dist/hooks/useSelectableDestChains.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSelectableDestChains.js","names":["SupportedChainId","useWidgetConfig","useEnabledDestChains","useGlobalDeltaEnabled","useAvailableCrosses","emptyArray","NonEmptyArray","BridgeInfoMode","useSelectableDestChains","t0","$","_c","fromChainId","mode","t1","availableCrosses","t2","undefined","enabledGlobally","deltaEnabledGlobally","enableCrossChain","enabledDestChains","t3","computeSelectableDestChains","selectableChains","t4","chain","includes","t5","isChainSelectable","canCrossChain","length","filter","unshift"],"sources":["../../src/hooks/useSelectableDestChains.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport { useWidgetConfig } from \"@/core/state/configAtom\";\nimport { useEnabledDestChains } from \"@/core/state/enabledChainsAtom\";\nimport { useGlobalDeltaEnabled } from \"./useGlobalDeltaEnabled\";\nimport { useAvailableCrosses } from \"./useAvailableCrosses\";\nimport { emptyArray } from \"@/lib/constants\";\nimport type { NonEmptyArray } from \"ts-essentials\";\nimport type { BridgeInfoMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\n\nexport function useSelectableDestChains({\n  fromChainId,\n  mode,\n}: {\n  fromChainId: SupportedChainId;\n  mode: BridgeInfoMode;\n}): {\n  selectableChains: SupportedChainId[];\n  isChainSelectable: (chain: SupportedChainId) => boolean;\n} {\n  const { availableCrosses = emptyArray } = useAvailableCrosses({\n    fromChainId,\n    mode,\n  });\n  const { enabledGlobally: deltaEnabledGlobally } = useGlobalDeltaEnabled();\n  const { enableCrossChain } = useWidgetConfig();\n  const enabledDestChains = useEnabledDestChains();\n\n  const selectableChains = computeSelectableDestChains({\n    enableCrossChain,\n    deltaEnabledGlobally,\n    enabledDestChains,\n    availableCrosses,\n    fromChainId,\n  });\n\n  return {\n    selectableChains,\n    isChainSelectable: (chain) => selectableChains.includes(chain),\n  };\n}\n\nexport function computeSelectableDestChains({\n  enableCrossChain,\n  deltaEnabledGlobally,\n  enabledDestChains,\n  availableCrosses,\n  fromChainId,\n}: {\n  enableCrossChain: boolean;\n  deltaEnabledGlobally: boolean;\n  enabledDestChains: NonEmptyArray<SupportedChainId>;\n  availableCrosses: SupportedChainId[];\n  fromChainId: SupportedChainId;\n}) {\n  const canCrossChain =\n    enableCrossChain && deltaEnabledGlobally && availableCrosses.length;\n\n  if (!canCrossChain) {\n    return [fromChainId];\n  }\n\n  const selectableChains = availableCrosses.filter((chain) =>\n    enabledDestChains.includes(chain)\n  );\n\n  if (!selectableChains.includes(fromChainId)) {\n    selectableChains.unshift(fromChainId);\n  }\n\n  return selectableChains;\n}\n"],"mappings":";;;;;;;AASA,SAAOQ,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,GAAA,EAAiC,EAAAC,gBAAAC,YAAAJ,GAMvCK;CAAA,AAAAJ,EAAA,OAAAE,KAAAF,EAAA,OAAAG,KAI+DC,IAAA;EAAAF;EAAAC;EAG7D,EAAAH,EAAA,KAAAE,GAAAF,EAAA,KAAAG,GAAAH,EAAA,KAAAI,KAAAA,IAAAJ,EAAA;CAHD,IAAA,EAAAK,kBAAAC,MAA0CZ,EAAoBU,EAG5D,EAHMC,IAAAC,MAAAC,KAAAA,IAAAZ,IAAAW,GAIR,EAAAE,iBAAAC,MAAkDhB,GAAuB,EACzE,EAAAiB,wBAA6BnB,GAAiB,EAC9CoB,IAA0BnB,GAAsB,EAACoB;CAAA,AAAAZ,EAAA,OAAAK,KAAAL,EAAA,OAAAS,KAAAT,EAAA,OAAAU,KAAAV,EAAA,OAAAW,KAAAX,EAAA,OAAAE,KAExBU,IAAAC,EAA4B;EAAAH;EAAAD;EAAAE;EAAAN;EAAAH;EAMpD,CAAC,EAAAF,EAAA,KAAAK,GAAAL,EAAA,KAAAS,GAAAT,EAAA,KAAAU,GAAAV,EAAA,KAAAW,GAAAX,EAAA,KAAAE,GAAAF,EAAA,KAAAY,KAAAA,IAAAZ,EAAA;CANF,IAAAc,IAAyBF,GAMtBG;CAAA,AAAAf,EAAA,OAAAc,IAI6DC,IAAAf,EAAA,OAA3Ce,KAAAC,MAAWF,EAAgBG,SAAUD,EAAM,EAAAhB,EAAA,KAAAc,GAAAd,EAAA,MAAAe;CAAA,IAAAG;CAC/D,OAD+DlB,EAAA,QAAAc,KAAAd,EAAA,QAAAe,KAFzDG,IAAA;EAAAJ;EAAAK,mBAEcJ;EACpB,EAAAf,EAAA,MAAAc,GAAAd,EAAA,MAAAe,GAAAf,EAAA,MAAAkB,KAAAA,IAAAlB,EAAA,KAHMkB;;AAMT,SAAgBL,EAA4B,EAC1CH,qBACAD,yBACAE,sBACAN,qBACAH,kBAOC;CAID,IAAI,EAFFQ,KAAoBD,KAAwBJ,EAAiBgB,SAG7D,OAAO,CAACnB,EAAY;CAGtB,IAAMY,IAAmBT,EAAiBiB,QAAQN,MAChDL,EAAkBM,SAASD,EAC7B,CAAC;CAMD,OAJKF,EAAiBG,SAASf,EAAY,IACzCY,EAAiBS,QAAQrB,EAAY,EAGhCY"}
+{"version":3,"file":"useSelectableDestChains.js","names":["SupportedChainId","useWidgetConfig","useEnabledDestChains","useGlobalDeltaEnabled","useAvailableCrosses","emptyArray","NonEmptyArray","BridgeRoutesMode","useSelectableDestChains","t0","$","_c","fromChainId","mode","t1","availableCrosses","t2","undefined","enabledGlobally","deltaEnabledGlobally","enableCrossChain","enabledDestChains","t3","computeSelectableDestChains","selectableChains","t4","chain","includes","t5","isChainSelectable","canCrossChain","length","filter","unshift"],"sources":["../../src/hooks/useSelectableDestChains.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport { useWidgetConfig } from \"@/core/state/configAtom\";\nimport { useEnabledDestChains } from \"@/core/state/enabledChainsAtom\";\nimport { useGlobalDeltaEnabled } from \"./useGlobalDeltaEnabled\";\nimport { useAvailableCrosses } from \"./useAvailableCrosses\";\nimport { emptyArray } from \"@/lib/constants\";\nimport type { NonEmptyArray } from \"ts-essentials\";\nimport type { BridgeRoutesMode } from \"./swap/prices/delta/queries/bridgeInfo/types\";\n\nexport function useSelectableDestChains({\n  fromChainId,\n  mode,\n}: {\n  fromChainId: SupportedChainId;\n  mode: BridgeRoutesMode;\n}): {\n  selectableChains: SupportedChainId[];\n  isChainSelectable: (chain: SupportedChainId) => boolean;\n} {\n  const { availableCrosses = emptyArray } = useAvailableCrosses({\n    fromChainId,\n    mode,\n  });\n  const { enabledGlobally: deltaEnabledGlobally } = useGlobalDeltaEnabled();\n  const { enableCrossChain } = useWidgetConfig();\n  const enabledDestChains = useEnabledDestChains();\n\n  const selectableChains = computeSelectableDestChains({\n    enableCrossChain,\n    deltaEnabledGlobally,\n    enabledDestChains,\n    availableCrosses,\n    fromChainId,\n  });\n\n  return {\n    selectableChains,\n    isChainSelectable: (chain) => selectableChains.includes(chain),\n  };\n}\n\nexport function computeSelectableDestChains({\n  enableCrossChain,\n  deltaEnabledGlobally,\n  enabledDestChains,\n  availableCrosses,\n  fromChainId,\n}: {\n  enableCrossChain: boolean;\n  deltaEnabledGlobally: boolean;\n  enabledDestChains: NonEmptyArray<SupportedChainId>;\n  availableCrosses: SupportedChainId[];\n  fromChainId: SupportedChainId;\n}) {\n  const canCrossChain =\n    enableCrossChain && deltaEnabledGlobally && availableCrosses.length;\n\n  if (!canCrossChain) {\n    return [fromChainId];\n  }\n\n  const selectableChains = availableCrosses.filter((chain) =>\n    enabledDestChains.includes(chain)\n  );\n\n  if (!selectableChains.includes(fromChainId)) {\n    selectableChains.unshift(fromChainId);\n  }\n\n  return selectableChains;\n}\n"],"mappings":";;;;;;;AASA,SAAOQ,EAAAC,GAAA;CAAA,IAAAC,IAAAC,EAAA,GAAA,EAAiC,EAAAC,gBAAAC,YAAAJ,GAMvCK;CAAA,AAAAJ,EAAA,OAAAE,KAAAF,EAAA,OAAAG,KAI+DC,IAAA;EAAAF;EAAAC;EAG7D,EAAAH,EAAA,KAAAE,GAAAF,EAAA,KAAAG,GAAAH,EAAA,KAAAI,KAAAA,IAAAJ,EAAA;CAHD,IAAA,EAAAK,kBAAAC,MAA0CZ,EAAoBU,EAG5D,EAHMC,IAAAC,MAAAC,KAAAA,IAAAZ,IAAAW,GAIR,EAAAE,iBAAAC,MAAkDhB,GAAuB,EACzE,EAAAiB,wBAA6BnB,GAAiB,EAC9CoB,IAA0BnB,GAAsB,EAACoB;CAAA,AAAAZ,EAAA,OAAAK,KAAAL,EAAA,OAAAS,KAAAT,EAAA,OAAAU,KAAAV,EAAA,OAAAW,KAAAX,EAAA,OAAAE,KAExBU,IAAAC,EAA4B;EAAAH;EAAAD;EAAAE;EAAAN;EAAAH;EAMpD,CAAC,EAAAF,EAAA,KAAAK,GAAAL,EAAA,KAAAS,GAAAT,EAAA,KAAAU,GAAAV,EAAA,KAAAW,GAAAX,EAAA,KAAAE,GAAAF,EAAA,KAAAY,KAAAA,IAAAZ,EAAA;CANF,IAAAc,IAAyBF,GAMtBG;CAAA,AAAAf,EAAA,OAAAc,IAI6DC,IAAAf,EAAA,OAA3Ce,KAAAC,MAAWF,EAAgBG,SAAUD,EAAM,EAAAhB,EAAA,KAAAc,GAAAd,EAAA,MAAAe;CAAA,IAAAG;CAC/D,OAD+DlB,EAAA,QAAAc,KAAAd,EAAA,QAAAe,KAFzDG,IAAA;EAAAJ;EAAAK,mBAEcJ;EACpB,EAAAf,EAAA,MAAAc,GAAAd,EAAA,MAAAe,GAAAf,EAAA,MAAAkB,KAAAA,IAAAlB,EAAA,KAHMkB;;AAMT,SAAgBL,EAA4B,EAC1CH,qBACAD,yBACAE,sBACAN,qBACAH,kBAOC;CAID,IAAI,EAFFQ,KAAoBD,KAAwBJ,EAAiBgB,SAG7D,OAAO,CAACnB,EAAY;CAGtB,IAAMY,IAAmBT,EAAiBiB,QAAQN,MAChDL,EAAkBM,SAASD,EAC7B,CAAC;CAMD,OAJKF,EAAiBG,SAASf,EAAY,IACzCY,EAAiBS,QAAQrB,EAAY,EAGhCY"}

package/dist/lib/queryClient.js

@@ -1,7 +1,7 @@
 import { getLogger as e } from "../core/logger.js";
-import { isDataDeltaOrBridgePrice as t } from "../hooks/swap/prices/delta/queries/useDeltaPriceQuery.js";
+import { isDataDeltaPrice as t } from "../hooks/swap/prices/delta/queries/useDeltaPriceQuery.js";
 import { notifyOnPriceChange as n } from "../events/effects/price.js";
-import { isDeltaAuctionData as r, isExecutedAuction as i } from "../hooks/swap/prices/delta/orders/utils.js";
+import { isCompletedAuction as r, isDeltaAuctionData as i } from "../hooks/swap/prices/delta/orders/utils.js";
 import { deltaAuctionPollingQueryKey as a } from "../hooks/swap/prices/delta/queries/useWatchDeltaOrder.js";
 import { isDataMarketPrice as o } from "../hooks/swap/prices/market/queries/useMarketPriceQuery.js";
 import { invalidateBalancesAndAllowancesFactory as s } from "../hooks/tokens/balances/useInvalidateTokenData.js";
@@ -21,7 +21,7 @@ var g = e("QueryCache"), _ = new f({
 			g.log(`waitForCallsStatusDataQuery:: batch ${e.id} success, invalidating balances and allowances`), v({ nonces: !1 });
 			return;
 		}
-		if (s === x && r(e) && i(e)) {
+		if (s === x && i(e) && r(e)) {
 			g.log(`deltaAuctionPollingQueryKey:: order ${e.id} is executed, invalidating balances and allowances`), v({ nonces: !!e.order.permit });
 			return;
 		}

package/dist/lib/queryClient.js.map

@@ -1 +1 @@
-{"version":3,"file":"queryClient.js","names":["getLogger","notifyOnPriceChange","isDeltaAuctionData","isExecutedDeltaAuction","DeltaPriceQueryKeyPrefix","isDataDeltaOrBridgePrice","deltaAuctionPollingQueryKey","isDataMarketPrice","MarketPriceQueryKeyPrefix","invalidateBalancesAndAllowancesFactory","isReceiptsInWaitForCallsStatusData","isTransactionReceipt","isWaitForCallsStatusData","QueryCache","QueryClient","hashFn","waitForCallsStatusQueryKey","waitForTransactionReceiptQueryKey","logger","queryClient","defaultOptions","queries","queryKeyHashFn","queryCache","onSuccess","data","query","queryKeyPrefix","queryKey","waitForTransactionReceiptQueryKeyPrefix","log","transactionHash","invalidateBalancesAndAllowances","nonces","waitForCallsStatusDataQueryKeyPrefix","status","id","deltaAuctionPollingQueryKeyPrefix","order","permit"],"sources":["../../src/lib/queryClient.ts"],"sourcesContent":["import { getLogger } from \"@/core/logger\";\nimport { notifyOnPriceChange } from \"@/events/effects/price\";\nimport {\n  isDeltaAuctionData,\n  isExecutedDeltaAuction,\n} from \"@/hooks/swap/prices/delta/orders/utils\";\nimport {\n  DeltaPriceQueryKeyPrefix,\n  isDataDeltaOrBridgePrice,\n} from \"@/hooks/swap/prices/delta/queries/useDeltaPriceQuery\";\nimport { deltaAuctionPollingQueryKey } from \"@/hooks/swap/prices/delta/queries/useWatchDeltaOrder\";\nimport {\n  isDataMarketPrice,\n  MarketPriceQueryKeyPrefix,\n} from \"@/hooks/swap/prices/market/queries/useMarketPriceQuery\";\nimport { invalidateBalancesAndAllowancesFactory } from \"@/hooks/tokens/balances/useInvalidateTokenData\";\nimport {\n  isReceiptsInWaitForCallsStatusData,\n  isTransactionReceipt,\n  isWaitForCallsStatusData,\n} from \"@/hooks/txs/queries/utils\";\nimport { QueryCache, QueryClient } from \"@tanstack/react-query\";\nimport {\n  hashFn,\n  waitForCallsStatusQueryKey,\n  waitForTransactionReceiptQueryKey,\n} from \"wagmi/query\";\n\nconst logger = getLogger(\"QueryCache\");\n\nexport const queryClient = new QueryClient({\n  defaultOptions: {\n    queries: {\n      queryKeyHashFn: hashFn, // for bigint support\n    },\n  },\n  queryCache: new QueryCache({\n    onSuccess(data, query) {\n      const queryKeyPrefix = query.queryKey[0];\n\n      if (\n        queryKeyPrefix === waitForTransactionReceiptQueryKeyPrefix &&\n        isTransactionReceipt(data)\n      ) {\n        logger.log(\n          `waitForTransactionReceiptQuery:: tx ${data.transactionHash} is mined, invalidating balances and allowances`\n        );\n        invalidateBalancesAndAllowances({ nonces: true });\n        return;\n      }\n\n      if (\n        queryKeyPrefix === waitForCallsStatusDataQueryKeyPrefix &&\n        isWaitForCallsStatusData(data) &&\n        data.status === \"success\" &&\n        isReceiptsInWaitForCallsStatusData(data)\n      ) {\n        logger.log(\n          `waitForCallsStatusDataQuery:: batch ${data.id} success, invalidating balances and allowances`\n        );\n        invalidateBalancesAndAllowances({ nonces: false });\n        return;\n      }\n\n      if (\n        queryKeyPrefix === deltaAuctionPollingQueryKeyPrefix &&\n        isDeltaAuctionData(data) &&\n        isExecutedDeltaAuction(data)\n      ) {\n        logger.log(\n          `deltaAuctionPollingQueryKey:: order ${data.id} is executed, invalidating balances and allowances`\n        );\n        invalidateBalancesAndAllowances({ nonces: !!data.order.permit });\n        return;\n      }\n\n      if (\n        queryKeyPrefix === DeltaPriceQueryKeyPrefix &&\n        isDataDeltaOrBridgePrice(data)\n      ) {\n        notifyOnPriceChange(data, queryClient);\n        return;\n      }\n\n      if (\n        queryKeyPrefix === MarketPriceQueryKeyPrefix &&\n        isDataMarketPrice(data)\n      ) {\n        notifyOnPriceChange(data, queryClient);\n        return;\n      }\n    },\n  }),\n});\n\nconst invalidateBalancesAndAllowances =\n  invalidateBalancesAndAllowancesFactory(queryClient);\n\nconst waitForTransactionReceiptQueryKeyPrefix =\n  waitForTransactionReceiptQueryKey()[0];\nconst waitForCallsStatusDataQueryKeyPrefix = waitForCallsStatusQueryKey({})[0];\nconst deltaAuctionPollingQueryKeyPrefix = deltaAuctionPollingQueryKey()[0];\n"],"mappings":";;;;;;;;;;;AA4BA,IAAMkB,IAASlB,EAAU,aAAa,EAEzBmB,IAAc,IAAIL,EAAY;CACzCM,gBAAgB,EACdC,SAAS,EACPC,gBAAgBP,GAClB,EACD;CACDQ,YAAY,IAAIV,EAAW,EACzBW,UAAUC,GAAMC,GAAO;EACrB,IAAMC,IAAiBD,EAAME,SAAS;EAEtC,IACED,MAAmBE,KACnBlB,EAAqBc,EAAK,EAC1B;GAIAO,AAHAd,EAAOY,IACL,uCAAuCL,EAAKM,gBAAe,iDAC5D,EACDC,EAAgC,EAAEC,QAAQ,IAAM,CAAC;GACjD;;EAGF,IACEN,MAAmBO,KACnBtB,EAAyBa,EAAK,IAC9BA,EAAKU,WAAW,aAChBzB,EAAmCe,EAAK,EACxC;GAIAO,AAHAd,EAAOY,IACL,uCAAuCL,EAAKW,GAAE,gDAC/C,EACDJ,EAAgC,EAAEC,QAAQ,IAAO,CAAC;GAClD;;EAGF,IACEN,MAAmBU,KACnBnC,EAAmBuB,EAAK,IACxBtB,EAAuBsB,EAAK,EAC5B;GAIAO,AAHAd,EAAOY,IACL,uCAAuCL,EAAKW,GAAE,oDAC/C,EACDJ,EAAgC,EAAEC,QAAQ,CAAC,CAACR,EAAKa,MAAMC,QAAQ,CAAC;GAChE;;EAGF,IACEZ,MAAAA,uBACAtB,EAAyBoB,EAAK,EAC9B;GACAxB,EAAoBwB,GAAMN,EAAY;GACtC;;EAGF,IACEQ,MAAAA,wBACApB,EAAkBkB,EAAK,EACvB;GACAxB,EAAoBwB,GAAMN,EAAY;GACtC;;IAGL,CAAA;CACF,CAAC,EAEIa,IACJvB,EAAuCU,EAAY,EAE/CU,IACJZ,GAAmC,CAAC,IAChCiB,IAAuClB,EAA2B,EAAE,CAAC,CAAC,IACtEqB,IAAoC/B,GAA6B,CAAC"}
+{"version":3,"file":"queryClient.js","names":["getLogger","notifyOnPriceChange","isCompletedDeltaAuction","isDeltaAuctionData","DeltaPriceQueryKeyPrefix","isDataDeltaPrice","deltaAuctionPollingQueryKey","isDataMarketPrice","MarketPriceQueryKeyPrefix","invalidateBalancesAndAllowancesFactory","isReceiptsInWaitForCallsStatusData","isTransactionReceipt","isWaitForCallsStatusData","QueryCache","QueryClient","hashFn","waitForCallsStatusQueryKey","waitForTransactionReceiptQueryKey","logger","queryClient","defaultOptions","queries","queryKeyHashFn","queryCache","onSuccess","data","query","queryKeyPrefix","queryKey","waitForTransactionReceiptQueryKeyPrefix","log","transactionHash","invalidateBalancesAndAllowances","nonces","waitForCallsStatusDataQueryKeyPrefix","status","id","deltaAuctionPollingQueryKeyPrefix","order","permit"],"sources":["../../src/lib/queryClient.ts"],"sourcesContent":["import { getLogger } from \"@/core/logger\";\nimport { notifyOnPriceChange } from \"@/events/effects/price\";\nimport {\n  isCompletedDeltaAuction,\n  isDeltaAuctionData,\n} from \"@/hooks/swap/prices/delta/orders/utils\";\nimport {\n  DeltaPriceQueryKeyPrefix,\n  isDataDeltaPrice,\n} from \"@/hooks/swap/prices/delta/queries/useDeltaPriceQuery\";\nimport { deltaAuctionPollingQueryKey } from \"@/hooks/swap/prices/delta/queries/useWatchDeltaOrder\";\nimport {\n  isDataMarketPrice,\n  MarketPriceQueryKeyPrefix,\n} from \"@/hooks/swap/prices/market/queries/useMarketPriceQuery\";\nimport { invalidateBalancesAndAllowancesFactory } from \"@/hooks/tokens/balances/useInvalidateTokenData\";\nimport {\n  isReceiptsInWaitForCallsStatusData,\n  isTransactionReceipt,\n  isWaitForCallsStatusData,\n} from \"@/hooks/txs/queries/utils\";\nimport { QueryCache, QueryClient } from \"@tanstack/react-query\";\nimport {\n  hashFn,\n  waitForCallsStatusQueryKey,\n  waitForTransactionReceiptQueryKey,\n} from \"wagmi/query\";\n\nconst logger = getLogger(\"QueryCache\");\n\nexport const queryClient = new QueryClient({\n  defaultOptions: {\n    queries: {\n      queryKeyHashFn: hashFn, // for bigint support\n    },\n  },\n  queryCache: new QueryCache({\n    onSuccess(data, query) {\n      const queryKeyPrefix = query.queryKey[0];\n\n      if (\n        queryKeyPrefix === waitForTransactionReceiptQueryKeyPrefix &&\n        isTransactionReceipt(data)\n      ) {\n        logger.log(\n          `waitForTransactionReceiptQuery:: tx ${data.transactionHash} is mined, invalidating balances and allowances`\n        );\n        invalidateBalancesAndAllowances({ nonces: true });\n        return;\n      }\n\n      if (\n        queryKeyPrefix === waitForCallsStatusDataQueryKeyPrefix &&\n        isWaitForCallsStatusData(data) &&\n        data.status === \"success\" &&\n        isReceiptsInWaitForCallsStatusData(data)\n      ) {\n        logger.log(\n          `waitForCallsStatusDataQuery:: batch ${data.id} success, invalidating balances and allowances`\n        );\n        invalidateBalancesAndAllowances({ nonces: false });\n        return;\n      }\n\n      if (\n        queryKeyPrefix === deltaAuctionPollingQueryKeyPrefix &&\n        isDeltaAuctionData(data) &&\n        isCompletedDeltaAuction(data)\n      ) {\n        logger.log(\n          `deltaAuctionPollingQueryKey:: order ${data.id} is executed, invalidating balances and allowances`\n        );\n        invalidateBalancesAndAllowances({ nonces: !!data.order.permit });\n        return;\n      }\n\n      if (\n        queryKeyPrefix === DeltaPriceQueryKeyPrefix &&\n        isDataDeltaPrice(data)\n      ) {\n        notifyOnPriceChange(data, queryClient);\n        return;\n      }\n\n      if (\n        queryKeyPrefix === MarketPriceQueryKeyPrefix &&\n        isDataMarketPrice(data)\n      ) {\n        notifyOnPriceChange(data, queryClient);\n        return;\n      }\n    },\n  }),\n});\n\nconst invalidateBalancesAndAllowances =\n  invalidateBalancesAndAllowancesFactory(queryClient);\n\nconst waitForTransactionReceiptQueryKeyPrefix =\n  waitForTransactionReceiptQueryKey()[0];\nconst waitForCallsStatusDataQueryKeyPrefix = waitForCallsStatusQueryKey({})[0];\nconst deltaAuctionPollingQueryKeyPrefix = deltaAuctionPollingQueryKey()[0];\n"],"mappings":";;;;;;;;;;;AA4BA,IAAMkB,IAASlB,EAAU,aAAa,EAEzBmB,IAAc,IAAIL,EAAY;CACzCM,gBAAgB,EACdC,SAAS,EACPC,gBAAgBP,GAClB,EACD;CACDQ,YAAY,IAAIV,EAAW,EACzBW,UAAUC,GAAMC,GAAO;EACrB,IAAMC,IAAiBD,EAAME,SAAS;EAEtC,IACED,MAAmBE,KACnBlB,EAAqBc,EAAK,EAC1B;GAIAO,AAHAd,EAAOY,IACL,uCAAuCL,EAAKM,gBAAe,iDAC5D,EACDC,EAAgC,EAAEC,QAAQ,IAAM,CAAC;GACjD;;EAGF,IACEN,MAAmBO,KACnBtB,EAAyBa,EAAK,IAC9BA,EAAKU,WAAW,aAChBzB,EAAmCe,EAAK,EACxC;GAIAO,AAHAd,EAAOY,IACL,uCAAuCL,EAAKW,GAAE,gDAC/C,EACDJ,EAAgC,EAAEC,QAAQ,IAAO,CAAC;GAClD;;EAGF,IACEN,MAAmBU,KACnBlC,EAAmBsB,EAAK,IACxBvB,EAAwBuB,EAAK,EAC7B;GAIAO,AAHAd,EAAOY,IACL,uCAAuCL,EAAKW,GAAE,oDAC/C,EACDJ,EAAgC,EAAEC,QAAQ,CAAC,CAACR,EAAKa,MAAMC,QAAQ,CAAC;GAChE;;EAGF,IACEZ,MAAAA,uBACAtB,EAAiBoB,EAAK,EACtB;GACAxB,EAAoBwB,GAAMN,EAAY;GACtC;;EAGF,IACEQ,MAAAA,wBACApB,EAAkBkB,EAAK,EACvB;GACAxB,EAAoBwB,GAAMN,EAAY;GACtC;;IAGL,CAAA;CACF,CAAC,EAEIa,IACJvB,EAAuCU,EAAY,EAE/CU,IACJZ,GAAmC,CAAC,IAChCiB,IAAuClB,EAA2B,EAAE,CAAC,CAAC,IACtEqB,IAAoC/B,GAA6B,CAAC"}

package/dist/lib/utils/price.d.ts

@@ -1,6 +1,6 @@
 import { DeltaOrMarketPrice } from '../../hooks/swap/prices/types';
 /**
- * Applies slippage to the srcAmount and destAmount of a DeltaOrMarketPrice.
+ * Applies slippage to a {srcAmount, destAmount} pair.
  *
  * @param srcAmount - The source amount of the trade.
  * @param destAmount - The destination amount of the trade.
@@ -8,7 +8,10 @@ import { DeltaOrMarketPrice } from '../../hooks/swap/prices/types';
  * @param side - The side of the trade, either "BUY" or "SELL".
  * @returns An object containing the adjusted srcAmount and destAmount after applying slippage.
  */
-export declare function applySlippage({ srcAmount, destAmount, }: Pick<DeltaOrMarketPrice, "srcAmount" | "destAmount">, slippage: number, side: "BUY" | "SELL"): {
+export declare function applySlippage({ srcAmount, destAmount }: {
+    srcAmount: string;
+    destAmount: string;
+}, slippage: number, side: "BUY" | "SELL"): {
     srcAmount: string;
     destAmount: string;
 };

package/dist/lib/utils/price.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"price.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/price.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAMpE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,EACE,SAAS,EACT,UAAU,GACX,EAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,GAAG,YAAY,CAAC,EACvD,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,KAAK,GAAG,MAAM;;;EAyBrB;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,kBAAkB,UAQ9D;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAAC,EAC/C,KAAK,EACL,eAAe,GAChB,EAAE;IACD,KAAK,EAAE,kBAAkB,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;CACzB,UAGA;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAGxD"}
+{"version":3,"file":"price.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/price.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAMpE;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,EACpE,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,KAAK,GAAG,MAAM;;;EAyBrB;AAMD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,kBAAkB,UAQ9D;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAAC,EAC/C,KAAK,EACL,eAAe,GAChB,EAAE;IACD,KAAK,EAAE,kBAAkB,CAAC;IAC1B,eAAe,EAAE,MAAM,CAAC;CACzB,UAGA;AAED,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,UAGxD"}

package/dist/lib/utils/price.js

@@ -13,15 +13,18 @@ function a({ srcAmount: e, destAmount: n }, r, i) {
 	};
 }
 function o(t) {
-	return r(e(t) ? t.receivedDestAmount : t.destAmount, t.partnerFee);
+	return e(t) ? t.partner.feePercent : t.partnerFee;
 }
-function s({ price: e, slippagePercent: t }) {
-	return n(o(e), t);
+function s(t) {
+	return r(e(t) ? t.route.destination.output.amount : t.destAmount, o(t));
 }
-function c(e, t) {
+function c({ price: e, slippagePercent: t }) {
+	return n(s(e), t);
+}
+function l(e, t) {
 	return t === 0 || e === t ? 0 : i(e).minus(t).div(t).mul(100).toNumber();
 }
 //#endregion
-export { a as applySlippage, o as getDestAmountAfterFee, s as getDestAmountAfterFeeAndSlippage, c as getPercentDifference };
+export { a as applySlippage, s as getDestAmountAfterFee, c as getDestAmountAfterFeeAndSlippage, l as getPercentDifference };
 
 //# sourceMappingURL=price.js.map