@velora-dex/widget 0.1.1 → 0.1.3

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

@@ -1 +1 @@
-{"version":3,"file":"useGlobalDeltaEnabled.d.ts","sourceRoot":"","sources":["../../src/hooks/useGlobalDeltaEnabled.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,qBAAqB;;;;;CAYjC,CAAC"}
+{"version":3,"file":"useGlobalDeltaEnabled.d.ts","sourceRoot":"","sources":["../../src/hooks/useGlobalDeltaEnabled.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,qBAAqB;;;;;;CAmBjC,CAAC"}

package/dist/hooks/useGlobalDeltaEnabled.js

@@ -7,30 +7,35 @@ import { useAtomValue } from 'jotai';
 import { useChainId } from 'wagmi';
 
 const useGlobalDeltaEnabled = () => {
-  const $ = distExports.c(5);
+  const $ = distExports.c(6);
   const chainId = useChainId();
   const widgetConfig = useWidgetConfig();
   const deltaParam = useAtomValue(deltaParamAtom);
   const swapMode = useAtomValue(swapModeAtom);
-  const t0 = deltaEnabledOnAPI[chainId];
-  const t1 = swapMode === "delta";
-  let t2;
-  if ($[0] !== deltaParam || $[1] !== t0 || $[2] !== t1 || $[3] !== widgetConfig.enableDelta) {
-    t2 = {
-      enabledInConfig: widgetConfig.enableDelta,
-      enabledInSettings: deltaParam,
-      enabledOnCurrentChain: t0,
-      isDeltaMode: t1
+  const enabledInConfig = widgetConfig.enableDelta;
+  const enabledInSettings = deltaParam;
+  const enabledOnCurrentChain = deltaEnabledOnAPI[chainId];
+  const enabledGlobally = enabledInConfig && enabledInSettings && enabledOnCurrentChain;
+  const t0 = swapMode === "delta";
+  let t1;
+  if ($[0] !== enabledGlobally || $[1] !== enabledInConfig || $[2] !== enabledInSettings || $[3] !== enabledOnCurrentChain || $[4] !== t0) {
+    t1 = {
+      enabledGlobally,
+      enabledInConfig,
+      enabledInSettings,
+      enabledOnCurrentChain,
+      isDeltaMode: t0
     };
-    $[0] = deltaParam;
-    $[1] = t0;
-    $[2] = t1;
-    $[3] = widgetConfig.enableDelta;
-    $[4] = t2;
+    $[0] = enabledGlobally;
+    $[1] = enabledInConfig;
+    $[2] = enabledInSettings;
+    $[3] = enabledOnCurrentChain;
+    $[4] = t0;
+    $[5] = t1;
   } else {
-    t2 = $[4];
+    t1 = $[5];
   }
-  return t2;
+  return t1;
 };
 
 export { useGlobalDeltaEnabled };

package/dist/hooks/useGlobalDeltaEnabled.js.map

@@ -1 +1 @@
-{"version":3,"file":"useGlobalDeltaEnabled.js","sources":["../../src/hooks/useGlobalDeltaEnabled.ts"],"sourcesContent":["import { swapModeAtom } from \"@/components/widget/SwapModeSwitcher/state/swapModeAtom\";\nimport { deltaParamAtom } from \"@/components/widget/TradeParameters/state/deltaParamAtom\";\nimport { deltaEnabledOnAPI } from \"@/lib/constants/delta\";\nimport { useWidgetConfig } from \"@/core/state/configAtom\";\nimport { useAtomValue } from \"jotai\";\nimport { useChainId } from \"wagmi\";\n\nexport const useGlobalDeltaEnabled = () => {\n  const chainId = useChainId();\n  const widgetConfig = useWidgetConfig();\n  const deltaParam = useAtomValue(deltaParamAtom);\n  const swapMode = useAtomValue(swapModeAtom);\n\n  return {\n    enabledInConfig: widgetConfig.enableDelta,\n    enabledInSettings: deltaParam,\n    enabledOnCurrentChain: deltaEnabledOnAPI[chainId],\n    isDeltaMode: swapMode === \"delta\",\n  };\n};\n"],"names":["useGlobalDeltaEnabled","$","_c","chainId","useChainId","widgetConfig","useWidgetConfig","deltaParam","useAtomValue","deltaParamAtom","swapMode","swapModeAtom","t0","deltaEnabledOnAPI","t1","t2","enableDelta","enabledInConfig","enabledInSettings","enabledOnCurrentChain","isDeltaMode"],"mappings":";;;;;;;;AAOO,MAAMA,wBAAwBA,MAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACnC,EAAA,MAAAC,UAAgBC,UAAAA,EAAW;AAC3B,EAAA,MAAAC,eAAqBC,eAAAA,EAAgB;AACrC,EAAA,MAAAC,UAAAA,GAAmBC,aAAAC,cAA2B,CAAA;AAC9C,EAAA,MAAAC,QAAAA,GAAiBF,aAAAG,YAAyB,CAAA;AAKjB,EAAA,MAAAC,EAAAA,GAAAC,kBAAkBV,OAAO,CAAA;AACnC,EAAA,MAAAW,KAAAJ,QAAAA,KAAa,OAAA;AAAO,EAAA,IAAAK,EAAAA;AAAA,EAAA,IAAAd,EAAA,CAAA,CAAA,KAAAM,UAAAA,IAAAN,CAAAA,QAAAW,EAAAA,IAAAX,CAAAA,CAAA,CAAA,MAAAa,EAAAA,IAAAb,CAAAA,CAAA,CAAA,CAAA,KAAAI,aAAAW,WAAAA,EAAA;AAJ5BD,IAAAA,EAAAA,GAAA;AAAA,MAAAE,iBACYZ,YAAAA,CAAYW,WAAAA;AAAAA,MAAAE,iBAAAA,EACVX,UAAAA;AAAAA,MAAUY,qBAAAA,EACNP,EAAAA;AAAAA,MAA0BQ,WAAAA,EACpCN;AAAAA,KAAoB;AAClCb,IAAAA,CAAAA,MAAAM,UAAAA;AAAAN,IAAAA,CAAAA,MAAAW,EAAAA;AAAAX,IAAAA,CAAAA,MAAAa,EAAAA;AAAAb,IAAAA,CAAAA,CAAA,CAAA,IAAAI,YAAAA,CAAAW,WAAAA;AAAAf,IAAAA,CAAAA,MAAAc,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAd,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OALMc,EAAAA;AAKN;;;;"}
+{"version":3,"file":"useGlobalDeltaEnabled.js","sources":["../../src/hooks/useGlobalDeltaEnabled.ts"],"sourcesContent":["import { swapModeAtom } from \"@/components/widget/SwapModeSwitcher/state/swapModeAtom\";\nimport { deltaParamAtom } from \"@/components/widget/TradeParameters/state/deltaParamAtom\";\nimport { deltaEnabledOnAPI } from \"@/lib/constants/delta\";\nimport { useWidgetConfig } from \"@/core/state/configAtom\";\nimport { useAtomValue } from \"jotai\";\nimport { useChainId } from \"wagmi\";\n\nexport const useGlobalDeltaEnabled = () => {\n  const chainId = useChainId();\n  const widgetConfig = useWidgetConfig();\n  const deltaParam = useAtomValue(deltaParamAtom);\n  const swapMode = useAtomValue(swapModeAtom);\n\n  const enabledInConfig = widgetConfig.enableDelta;\n  const enabledInSettings = deltaParam;\n  const enabledOnCurrentChain = deltaEnabledOnAPI[chainId];\n  const enabledGlobally =\n    enabledInConfig && enabledInSettings && enabledOnCurrentChain;\n\n  return {\n    enabledGlobally,\n    enabledInConfig,\n    enabledInSettings,\n    enabledOnCurrentChain,\n    isDeltaMode: swapMode === \"delta\",\n  };\n};\n"],"names":["useGlobalDeltaEnabled","$","_c","chainId","useChainId","widgetConfig","useWidgetConfig","deltaParam","useAtomValue","deltaParamAtom","swapMode","swapModeAtom","enabledInConfig","enableDelta","enabledInSettings","enabledOnCurrentChain","deltaEnabledOnAPI","enabledGlobally","t0","t1","isDeltaMode"],"mappings":";;;;;;;;AAOO,MAAMA,wBAAwBA,MAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACnC,EAAA,MAAAC,UAAgBC,UAAAA,EAAW;AAC3B,EAAA,MAAAC,eAAqBC,eAAAA,EAAgB;AACrC,EAAA,MAAAC,UAAAA,GAAmBC,aAAAC,cAA2B,CAAA;AAC9C,EAAA,MAAAC,QAAAA,GAAiBF,aAAAG,YAAyB,CAAA;AAE1C,EAAA,MAAAC,kBAAwBP,YAAAA,CAAYQ,WAAAA;AACpC,EAAA,MAAAC,iBAAAA,GAA0BP,UAAAA;AAC1B,EAAA,MAAAQ,qBAAAA,GAAAC,kBAAgDb,OAAO,CAAA;AACvD,EAAA,MAAAc,eAAAA,GACEL,mBAAmBE,iBAAAA,IAAqBC,qBAAAA;AAO3B,EAAA,MAAAG,KAAAR,QAAAA,KAAa,OAAA;AAAO,EAAA,IAAAS,EAAAA;AAAA,EAAA,IAAAlB,EAAA,CAAA,CAAA,KAAAgB,mBAAAhB,CAAAA,CAAA,CAAA,MAAAW,eAAAA,IAAAX,CAAAA,CAAA,CAAA,CAAA,KAAAa,iBAAAA,IAAAb,EAAA,CAAA,CAAA,KAAAc,yBAAAd,CAAAA,QAAAiB,EAAAA,EAAA;AAL5BC,IAAAA,EAAAA,GAAA;AAAA,MAAAF,eAAAA;AAAAA,MAAAL,eAAAA;AAAAA,MAAAE,iBAAAA;AAAAA,MAAAC,qBAAAA;AAAAA,MAAAK,WAAAA,EAKQF;AAAAA,KAAoB;AAClCjB,IAAAA,CAAAA,MAAAgB,eAAAA;AAAAhB,IAAAA,CAAAA,MAAAW,eAAAA;AAAAX,IAAAA,CAAAA,MAAAa,iBAAAA;AAAAb,IAAAA,CAAAA,MAAAc,qBAAAA;AAAAd,IAAAA,CAAAA,MAAAiB,EAAAA;AAAAjB,IAAAA,CAAAA,MAAAkB,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAlB,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OANMkB,EAAAA;AAMN;;;;"}

package/dist/hooks/useSelectableDestChains.d.ts

@@ -0,0 +1,14 @@
+import { SupportedChainId } from '../lib/web3/wagmi/types';
+import { NonEmptyArray } from 'ts-essentials';
+export declare function useSelectableDestChains(fromChainId: SupportedChainId): {
+    selectableChains: SupportedChainId[];
+    isChainSelectable: (chain: SupportedChainId) => boolean;
+};
+export declare function computeSelectableDestChains({ enableCrossChain, deltaEnabledGlobally, enabledDestChains, availableCrosses, fromChainId, }: {
+    enableCrossChain: boolean;
+    deltaEnabledGlobally: boolean;
+    enabledDestChains: NonEmptyArray<SupportedChainId>;
+    availableCrosses: SupportedChainId[];
+    fromChainId: SupportedChainId;
+}): (1 | 10 | 137 | 56 | 43114 | 42161 | 8453 | 100 | 146 | 130)[];
+//# sourceMappingURL=useSelectableDestChains.d.ts.map

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

@@ -0,0 +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;AAEnD,wBAAgB,uBAAuB,CAAC,WAAW,EAAE,gBAAgB,GAAG;IACtE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;IACrC,iBAAiB,EAAE,CAAC,KAAK,EAAE,gBAAgB,KAAK,OAAO,CAAC;CACzD,CAoBA;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,kEAiBA"}

package/dist/hooks/useSelectableDestChains.js

@@ -0,0 +1,91 @@
+import { d as distExports } from '../_virtual/index.js';
+import { useWidgetConfig } from '../core/state/configAtom.js';
+import { useEnabledDestChains } from '../core/state/enabledChainsAtom.js';
+import { useGlobalDeltaEnabled } from './useGlobalDeltaEnabled.js';
+import { useAvailableCrosses } from './useAvailableCrosses.js';
+import { emptyArray } from '../lib/constants/index.js';
+
+function useSelectableDestChains(fromChainId) {
+  const $ = distExports.c(13);
+  let t0;
+  if ($[0] !== fromChainId) {
+    t0 = {
+      fromChainId
+    };
+    $[0] = fromChainId;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const {
+    availableCrosses: t1
+  } = useAvailableCrosses(t0);
+  const availableCrosses = t1 === void 0 ? emptyArray : t1;
+  const {
+    enabledGlobally: deltaEnabledGlobally
+  } = useGlobalDeltaEnabled();
+  const {
+    enableCrossChain
+  } = useWidgetConfig();
+  const enabledDestChains = useEnabledDestChains();
+  let t2;
+  if ($[2] !== availableCrosses || $[3] !== deltaEnabledGlobally || $[4] !== enableCrossChain || $[5] !== enabledDestChains || $[6] !== fromChainId) {
+    t2 = computeSelectableDestChains({
+      enableCrossChain,
+      deltaEnabledGlobally,
+      enabledDestChains,
+      availableCrosses,
+      fromChainId
+    });
+    $[2] = availableCrosses;
+    $[3] = deltaEnabledGlobally;
+    $[4] = enableCrossChain;
+    $[5] = enabledDestChains;
+    $[6] = fromChainId;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  const selectableChains = t2;
+  let t3;
+  if ($[8] !== selectableChains) {
+    t3 = (chain) => selectableChains.includes(chain);
+    $[8] = selectableChains;
+    $[9] = t3;
+  } else {
+    t3 = $[9];
+  }
+  let t4;
+  if ($[10] !== selectableChains || $[11] !== t3) {
+    t4 = {
+      selectableChains,
+      isChainSelectable: t3
+    };
+    $[10] = selectableChains;
+    $[11] = t3;
+    $[12] = t4;
+  } else {
+    t4 = $[12];
+  }
+  return t4;
+}
+function computeSelectableDestChains({
+  enableCrossChain,
+  deltaEnabledGlobally,
+  enabledDestChains,
+  availableCrosses,
+  fromChainId
+}) {
+  const canCrossChain = enableCrossChain && deltaEnabledGlobally && availableCrosses.length;
+  if (!canCrossChain) {
+    return [fromChainId];
+  }
+  const selectableChains = availableCrosses.filter((chain) => enabledDestChains.includes(chain));
+  if (!selectableChains.includes(fromChainId)) {
+    selectableChains.unshift(fromChainId);
+  }
+  return selectableChains;
+}
+
+export { computeSelectableDestChains, useSelectableDestChains };
+//# sourceMappingURL=useSelectableDestChains.js.map

package/dist/hooks/useSelectableDestChains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSelectableDestChains.js","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\";\n\nexport function useSelectableDestChains(fromChainId: SupportedChainId): {\n  selectableChains: SupportedChainId[];\n  isChainSelectable: (chain: SupportedChainId) => boolean;\n} {\n  const { availableCrosses = emptyArray } = useAvailableCrosses({\n    fromChainId,\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"],"names":["useSelectableDestChains","fromChainId","$","_c","t0","availableCrosses","t1","useAvailableCrosses","undefined","emptyArray","enabledGlobally","deltaEnabledGlobally","useGlobalDeltaEnabled","enableCrossChain","useWidgetConfig","enabledDestChains","useEnabledDestChains","t2","computeSelectableDestChains","selectableChains","t3","chain","includes","t4","isChainSelectable","canCrossChain","length","filter","unshift"],"mappings":";;;;;;;AAQO,SAAAA,wBAAAC,WAAAA,EAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,EAAA,CAAA;AAAA,EAAA,IAAAC,EAAAA;AAAA,EAAA,IAAAF,CAAAA,QAAAD,WAAAA,EAAA;AAIyDG,IAAAA,EAAAA,GAAA;AAAA,MAAAH;AAAAA,KAAA;AAE7DC,IAAAA,CAAAA,MAAAD,WAAAA;AAAAC,IAAAA,CAAAA,MAAAE,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAF,EAAA,CAAA,CAAA;AAAA,EAAA;AAFD,EAAA,MAAA;AAAA,IAAAG,gBAAAA,EAAAC;AAAAA,GAAA,GAA0CC,oBAAoBH,EAE7D,CAAA;AAFO,EAAA,MAAAC,gBAAAA,GAAAC,EAAAA,KAA6BE,MAAAA,GAAAC,UAAAA,GAA7BH,EAAAA;AAGR,EAAA,MAAA;AAAA,IAAAI,eAAAA,EAAAC;AAAAA,MAAkDC,qBAAAA,EAAsB;AACxE,EAAA,MAAA;AAAA,IAAAC;AAAAA,MAA6BC,eAAAA,EAAgB;AAC7C,EAAA,MAAAC,oBAA0BC,oBAAAA,EAAqB;AAAE,EAAA,IAAAC,EAAAA;AAAA,EAAA,IAAAf,EAAA,CAAA,CAAA,KAAAG,oBAAAH,CAAAA,CAAA,CAAA,MAAAS,oBAAAA,IAAAT,CAAAA,CAAA,CAAA,CAAA,KAAAW,gBAAAA,IAAAX,EAAA,CAAA,CAAA,KAAAa,qBAAAb,CAAAA,QAAAD,WAAAA,EAAA;AAExBgB,IAAAA,EAAAA,GAAAC,2BAAAA,CAAA;AAAA,MAAAL,gBAAAA;AAAAA,MAAAF,oBAAAA;AAAAA,MAAAI,iBAAAA;AAAAA,MAAAV,gBAAAA;AAAAA,MAAAJ;AAAAA,KAMxB,CAAA;AAACC,IAAAA,CAAAA,MAAAG,gBAAAA;AAAAH,IAAAA,CAAAA,MAAAS,oBAAAA;AAAAT,IAAAA,CAAAA,MAAAW,gBAAAA;AAAAX,IAAAA,CAAAA,MAAAa,iBAAAA;AAAAb,IAAAA,CAAAA,MAAAD,WAAAA;AAAAC,IAAAA,CAAAA,MAAAe,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAf,EAAA,CAAA,CAAA;AAAA,EAAA;AANF,EAAA,MAAAiB,gBAAAA,GAAyBF,EAAAA;AAMtB,EAAA,IAAAG,EAAAA;AAAA,EAAA,IAAAlB,CAAAA,QAAAiB,gBAAAA,EAAA;AAIkBC,IAAAA,EAAAA,GAAAC,CAAAA,KAAAA,KAAWF,gBAAAA,CAAgBG,QAAAA,CAAUD,KAAK,CAAA;AAACnB,IAAAA,CAAAA,MAAAiB,gBAAAA;AAAAjB,IAAAA,CAAAA,MAAAkB,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAlB,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,IAAAqB,EAAAA;AAAA,EAAA,IAAArB,EAAA,EAAA,CAAA,KAAAiB,oBAAAjB,CAAAA,SAAAkB,EAAAA,EAAA;AAFzDG,IAAAA,EAAAA,GAAA;AAAA,MAAAJ,gBAAAA;AAAAA,MAAAK,iBAAAA,EAEcJ;AAAAA,KAA2C;AAC/DlB,IAAAA,CAAAA,OAAAiB,gBAAAA;AAAAjB,IAAAA,CAAAA,OAAAkB,EAAAA;AAAAlB,IAAAA,CAAAA,OAAAqB,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAArB,EAAA,EAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAHMqB,EAAAA;AAGN;AAGI,SAASL,2BAAAA,CAA4B;AAAA,EAC1CL,gBAAAA;AAAAA,EACAF,oBAAAA;AAAAA,EACAI,iBAAAA;AAAAA,EACAV,gBAAAA;AAAAA,EACAJ;AAOF,CAAA,EAAG;AACD,EAAA,MAAMwB,aAAAA,GACJZ,gBAAAA,IAAoBF,oBAAAA,IAAwBN,gBAAAA,CAAiBqB,MAAAA;AAE/D,EAAA,IAAI,CAACD,aAAAA,EAAe;AAClB,IAAA,OAAO,CAACxB,WAAW,CAAA;AAAA,EACrB;AAEA,EAAA,MAAMkB,mBAAmBd,gBAAAA,CAAiBsB,MAAAA,CAAQN,WAChDN,iBAAAA,CAAkBO,QAAAA,CAASD,KAAK,CAClC,CAAA;AAEA,EAAA,IAAI,CAACF,gBAAAA,CAAiBG,QAAAA,CAASrB,WAAW,CAAA,EAAG;AAC3CkB,IAAAA,gBAAAA,CAAiBS,QAAQ3B,WAAW,CAAA;AAAA,EACtC;AAEA,EAAA,OAAOkB,gBAAAA;AACT;;;;"}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { Widget } from './core';
 export type { WidgetProps, WidgetConfig, WidgetTheme, EIP1193ProviderLax, } from './core/types';
+export type { SupportedChainId } from './lib/web3/wagmi/types';
+export { defaults } from './core/constants';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,YAAY,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,kBAAkB,GACnB,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGhC,YAAY,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACX,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -1,2 +1,3 @@
 export { Widget } from './core/index.js';
+export { defaults } from './core/constants.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/lib/constants/delta.js

@@ -10,7 +10,7 @@ const deltaEnabledOnAPI = {
   [avalanche.id]: false,
   [base.id]: true,
   [sonic.id]: false,
-  [unichain.id]: false
+  [unichain.id]: true
 };
 const CHAINS_WITH_DELTA = Object.entries(deltaEnabledOnAPI).flatMap(([chainId, enabled]) => enabled ? [Number(chainId)] : []);
 

package/dist/lib/constants/delta.js.map

@@ -1 +1 @@
-{"version":3,"file":"delta.js","sources":["../../../src/lib/constants/delta.ts"],"sourcesContent":["import {\n  arbitrum,\n  avalanche,\n  base,\n  bsc,\n  gnosis,\n  mainnet,\n  optimism,\n  polygon,\n  sonic,\n  unichain,\n} from \"../web3/wagmi/supportedChains\";\nimport type { SupportedChainId } from \"../web3/wagmi/types\";\n\nexport const deltaEnabledOnAPI: Record<SupportedChainId, boolean> = {\n  [mainnet.id]: true,\n  [optimism.id]: true,\n  [bsc.id]: true,\n  [gnosis.id]: false,\n  [polygon.id]: true,\n  [arbitrum.id]: true,\n  [avalanche.id]: false,\n  [base.id]: true,\n  [sonic.id]: false,\n  [unichain.id]: false,\n};\n\nexport const CHAINS_WITH_DELTA = Object.entries(deltaEnabledOnAPI).flatMap(\n  ([chainId, enabled]) => (enabled ? [Number(chainId) as SupportedChainId] : [])\n);\n"],"names":["deltaEnabledOnAPI","mainnet","id","optimism","bsc","gnosis","polygon","arbitrum","avalanche","base","sonic","unichain","CHAINS_WITH_DELTA","Object","entries","flatMap","chainId","enabled","Number"],"mappings":";;AAcO,MAAMA,iBAAAA,GAAuD;AAAA,EAClE,CAACC,OAAAA,CAAQC,EAAE,GAAG,IAAA;AAAA,EACd,CAACC,QAAAA,CAASD,EAAE,GAAG,IAAA;AAAA,EACf,CAACE,GAAAA,CAAIF,EAAE,GAAG,IAAA;AAAA,EACV,CAACG,MAAAA,CAAOH,EAAE,GAAG,KAAA;AAAA,EACb,CAACI,OAAAA,CAAQJ,EAAE,GAAG,IAAA;AAAA,EACd,CAACK,QAAAA,CAASL,EAAE,GAAG,IAAA;AAAA,EACf,CAACM,SAAAA,CAAUN,EAAE,GAAG,KAAA;AAAA,EAChB,CAACO,IAAAA,CAAKP,EAAE,GAAG,IAAA;AAAA,EACX,CAACQ,KAAAA,CAAMR,EAAE,GAAG,KAAA;AAAA,EACZ,CAACS,QAAAA,CAAST,EAAE,GAAG;AACjB;AAEO,MAAMU,oBAAoBC,MAAAA,CAAOC,OAAAA,CAAQd,iBAAiB,CAAA,CAAEe,OAAAA,CACjE,CAAC,CAACC,OAAAA,EAASC,OAAO,CAAA,KAAOA,UAAU,CAACC,MAAAA,CAAOF,OAAO,CAAqB,CAAA,GAAI,EAC7E;;;;"}
+{"version":3,"file":"delta.js","sources":["../../../src/lib/constants/delta.ts"],"sourcesContent":["import {\n  arbitrum,\n  avalanche,\n  base,\n  bsc,\n  gnosis,\n  mainnet,\n  optimism,\n  polygon,\n  sonic,\n  unichain,\n} from \"../web3/wagmi/supportedChains\";\nimport type { SupportedChainId } from \"../web3/wagmi/types\";\n\nexport const deltaEnabledOnAPI: Record<SupportedChainId, boolean> = {\n  [mainnet.id]: true,\n  [optimism.id]: true,\n  [bsc.id]: true,\n  [gnosis.id]: false,\n  [polygon.id]: true,\n  [arbitrum.id]: true,\n  [avalanche.id]: false,\n  [base.id]: true,\n  [sonic.id]: false,\n  [unichain.id]: true,\n};\n\nexport const CHAINS_WITH_DELTA = Object.entries(deltaEnabledOnAPI).flatMap(\n  ([chainId, enabled]) => (enabled ? [Number(chainId) as SupportedChainId] : [])\n);\n"],"names":["deltaEnabledOnAPI","mainnet","id","optimism","bsc","gnosis","polygon","arbitrum","avalanche","base","sonic","unichain","CHAINS_WITH_DELTA","Object","entries","flatMap","chainId","enabled","Number"],"mappings":";;AAcO,MAAMA,iBAAAA,GAAuD;AAAA,EAClE,CAACC,OAAAA,CAAQC,EAAE,GAAG,IAAA;AAAA,EACd,CAACC,QAAAA,CAASD,EAAE,GAAG,IAAA;AAAA,EACf,CAACE,GAAAA,CAAIF,EAAE,GAAG,IAAA;AAAA,EACV,CAACG,MAAAA,CAAOH,EAAE,GAAG,KAAA;AAAA,EACb,CAACI,OAAAA,CAAQJ,EAAE,GAAG,IAAA;AAAA,EACd,CAACK,QAAAA,CAASL,EAAE,GAAG,IAAA;AAAA,EACf,CAACM,SAAAA,CAAUN,EAAE,GAAG,KAAA;AAAA,EAChB,CAACO,IAAAA,CAAKP,EAAE,GAAG,IAAA;AAAA,EACX,CAACQ,KAAAA,CAAMR,EAAE,GAAG,KAAA;AAAA,EACZ,CAACS,QAAAA,CAAST,EAAE,GAAG;AACjB;AAEO,MAAMU,oBAAoBC,MAAAA,CAAOC,OAAAA,CAAQd,iBAAiB,CAAA,CAAEe,OAAAA,CACjE,CAAC,CAACC,OAAAA,EAASC,OAAO,CAAA,KAAOA,UAAU,CAACC,MAAAA,CAAOF,OAAO,CAAqB,CAAA,GAAI,EAC7E;;;;"}

package/dist/lib/tradeMode.d.ts

@@ -0,0 +1,4 @@
+import { TradeMode } from '../core/state/tradeModeAtom';
+export declare const supportedTradeModes: ["swap", "limit", "otc"];
+export declare function isTradeMode(mode: string): mode is TradeMode;
+//# sourceMappingURL=tradeMode.d.ts.map

package/dist/lib/tradeMode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tradeMode.d.ts","sourceRoot":"","sources":["../../src/lib/tradeMode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAG5D,eAAO,MAAM,mBAAmB,0BAIa,CAAC;AAI9C,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,IAAI,SAAS,CAE3D"}

package/dist/lib/tradeMode.js

@@ -0,0 +1,8 @@
+const supportedTradeModes = ["swap", "limit", "otc"];
+const validTradeModes = supportedTradeModes;
+function isTradeMode(mode) {
+  return validTradeModes.includes(mode);
+}
+
+export { isTradeMode, supportedTradeModes };
+//# sourceMappingURL=tradeMode.js.map

package/dist/lib/tradeMode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tradeMode.js","sources":["../../src/lib/tradeMode.ts"],"sourcesContent":["import type { TradeMode } from \"@/core/state/tradeModeAtom\";\nimport type { NonEmptyArray } from \"ts-essentials\";\n\nexport const supportedTradeModes = [\n  \"swap\",\n  \"limit\",\n  \"otc\",\n] as const satisfies NonEmptyArray<TradeMode>;\n\nconst validTradeModes: string[] = supportedTradeModes;\n\nexport function isTradeMode(mode: string): mode is TradeMode {\n  return validTradeModes.includes(mode);\n}\n"],"names":["supportedTradeModes","validTradeModes","isTradeMode","mode","includes"],"mappings":"AAGO,MAAMA,mBAAAA,GAAsB,CACjC,MAAA,EACA,OAAA,EACA,KAAK;AAGP,MAAMC,eAAAA,GAA4BD,mBAAAA;AAE3B,SAASE,YAAYC,IAAAA,EAAiC;AAC3D,EAAA,OAAOF,eAAAA,CAAgBG,SAASD,IAAI,CAAA;AACtC;;;;"}

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

@@ -0,0 +1,2 @@
+export declare function atomWithCompare<Value>(initialValue: Value, areEqual: (prev: Value, next: Value) => boolean): import('jotai').WritableAtom<Value, [Value], void>;
+//# sourceMappingURL=atomWithCompare.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"atomWithCompare.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/atomWithCompare.ts"],"names":[],"mappings":"AAEA,wBAAgB,eAAe,CAAC,KAAK,EACnC,YAAY,EAAE,KAAK,EACnB,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,KAAK,OAAO,sDAShD"}

package/dist/lib/utils/atomWithCompare.js

@@ -0,0 +1,13 @@
+import { atomWithReducer } from 'jotai/utils';
+
+function atomWithCompare(initialValue, areEqual) {
+  return atomWithReducer(initialValue, (prev, next) => {
+    if (areEqual(prev, next)) {
+      return prev;
+    }
+    return next;
+  });
+}
+
+export { atomWithCompare };
+//# sourceMappingURL=atomWithCompare.js.map

package/dist/lib/utils/atomWithCompare.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomWithCompare.js","sources":["../../../src/lib/utils/atomWithCompare.ts"],"sourcesContent":["import { atomWithReducer } from \"jotai/utils\";\n\nexport function atomWithCompare<Value>(\n  initialValue: Value,\n  areEqual: (prev: Value, next: Value) => boolean\n) {\n  return atomWithReducer(initialValue, (prev: Value, next: Value) => {\n    if (areEqual(prev, next)) {\n      return prev;\n    }\n\n    return next;\n  });\n}\n"],"names":["atomWithCompare","initialValue","areEqual","atomWithReducer","prev","next"],"mappings":";;AAEO,SAASA,eAAAA,CACdC,cACAC,QAAAA,EACA;AACA,EAAA,OAAOC,eAAAA,CAAgBF,YAAAA,EAAc,CAACG,IAAAA,EAAaC,IAAAA,KAAgB;AACjE,IAAA,IAAIH,QAAAA,CAASE,IAAAA,EAAMC,IAAI,CAAA,EAAG;AACxB,MAAA,OAAOD,IAAAA;AAAAA,IACT;AAEA,IAAA,OAAOC,IAAAA;AAAAA,EACT,CAAC,CAAA;AACH;;;;"}

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

@@ -24,5 +24,7 @@ export declare const stringIncludes: (a: string, b: string) => boolean;
 export declare const shortenText: (str: string, start: number, end?: number) => string;
 export declare function shortenAddress(address: string, slashIndex?: number, rightCutLength?: number): string;
 export declare function replaceUnderscoresWithSpaces(str: string): string;
+export declare function isValidUrl(url: string): boolean;
+export declare function unorderedShallowEqual<T>(a: T[], b: T[]): boolean;
 export {};
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAI7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAKD,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,QAAQ,EAAE,CAAC,EAAE,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAC5B,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AACrB,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EACtC,QAAQ,EAAE,CAAC,EAAE,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC7B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,GACvC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAwBrB,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,QAAQ,EAAE,CAAC,EAAE,EAEb,mBAAmB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,GACvC,CAAC,EAAE,CAWL;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,KAC5C,CAAC,IAAI,CAAQ,CAAC;AAEjB,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAChD,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAEtB;AAED,KAAK,cAAc,CAAC,CAAC,IAAI,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE5C,wBAAgB,UAAU,CACxB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,EACjB,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAE1E;AAED,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,eAAO,MAAM,yBAAyB,GAAI,cAEvC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,YAAqC,CAAC;AAE/D,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,OAErD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GACtB,KAAK,MAAM,EACX,OAAO,MAAM,EACb,MAAK,MAAU,KACd,MAGF,CAAC;AAEF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,SAAI,EACd,cAAc,SAAI,GACjB,MAAM,CAGR;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAC;AAI7C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC;AAKD,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,QAAQ,EAAE,CAAC,EAAE,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAC5B,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AACrB,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,CAAC,EACtC,QAAQ,EAAE,CAAC,EAAE,EACb,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,EAC7B,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,KAAK,CAAC,GACvC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;AAwBrB,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,QAAQ,EAAE,CAAC,EAAE,EAEb,mBAAmB,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,GACvC,CAAC,EAAE,CAWL;AAED,eAAO,MAAM,QAAQ,GAAI,CAAC,EACxB,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,GAAG,SAAS,KAC5C,CAAC,IAAI,CAAQ,CAAC;AAEjB,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAChD,KAAK,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC,CAEtB;AAED,KAAK,cAAc,CAAC,CAAC,IAAI,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;AAE5C,wBAAgB,UAAU,CACxB,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,MAAM,CAAC,EACjB,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,OAAO,CAAC,GAAG,IAAI,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,CAE1E;AAED,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,eAAO,MAAM,yBAAyB,GAAI,cAEvC,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,YAAqC,CAAC;AAE/D,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,OAErD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GACtB,KAAK,MAAM,EACX,OAAO,MAAM,EACb,MAAK,MAAU,KACd,MAGF,CAAC;AAEF,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,SAAI,EACd,cAAc,SAAI,GACjB,MAAM,CAGR;AAED,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEhE;AAED,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,WAOrC;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,WAOtD"}

package/dist/lib/utils/index.js

@@ -53,6 +53,22 @@ function shortenAddress(address, slashIndex = 6, rightCutLength = 4) {
 function replaceUnderscoresWithSpaces(str) {
   return str.replace(/_/g, " ");
 }
+function isValidUrl(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function unorderedShallowEqual(a, b) {
+  if (a.length !== b.length) return false;
+  const setA = new Set(a);
+  for (const item of b) {
+    if (!setA.has(item)) return false;
+  }
+  return true;
+}
 
-export { assertProp, cn, filterInvalidTokenAddress, filterUnique, gatherObjectsByProp, hasCorrectAddressLength, isNonNullableEntry, isTruthy, replaceUnderscoresWithSpaces, shortenAddress, shortenText, stringIncludes };
+export { assertProp, cn, filterInvalidTokenAddress, filterUnique, gatherObjectsByProp, hasCorrectAddressLength, isNonNullableEntry, isTruthy, isValidUrl, replaceUnderscoresWithSpaces, shortenAddress, shortenText, stringIncludes, unorderedShallowEqual };
 //# sourceMappingURL=index.js.map

package/dist/lib/utils/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../src/lib/utils/index.ts"],"sourcesContent":["import type { Token } from \"@/tokens/state/types\";\nimport { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\nimport { assert } from \"ts-essentials\";\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n\n// reduce element[] to Object{key: prop, val?: element}\n// for example\n// gatherObjectsByProp(Token[], token => token.address) => Record<address, Token|undefined>\nexport function gatherObjectsByProp<T>(\n  elements: T[],\n  pickProp: (elem: T) => string\n): Record<string, T>;\nexport function gatherObjectsByProp<T, U>(\n  elements: T[],\n  pickProp: (elem: T) => string,\n  transform: (elem: T, accumElem?: U) => U\n): Record<string, U>;\nexport function gatherObjectsByProp<T, U>(\n  elements: T[],\n  pickProp: (elem: T) => string,\n  transform?: (elem: T, accumElem?: U) => U\n): Record<string, T> | Record<string, U> {\n  return elements.reduce<Record<string, T> | Record<string, U>>(\n    (accum, element) => {\n      const key = pickProp(element);\n\n      const accumElem: T | U | undefined = accum[key];\n      const transformedElement = transform\n        ? //                       if transform is available, can only be U | undefined\n          transform(element, accumElem as U | undefined)\n        : element;\n\n      accum[key] = transformedElement;\n\n      return accum;\n    },\n    {}\n  );\n}\n\nexport function filterUnique<T, U>(\n  elements: T[],\n  // supports multikey filtering, if only one key required return [U]\n  constructUniqueKeys: (element: T) => U[]\n): T[] {\n  if (elements.length <= 1) return elements;\n  const hasSeen = new Set<U>();\n\n  return elements.filter((element) => {\n    const keys = constructUniqueKeys(element);\n    if (keys.some((key) => hasSeen.has(key))) return false;\n\n    keys.forEach((key) => hasSeen.add(key));\n    return true;\n  });\n}\n\nexport const isTruthy = <T>(\n  x: T | false | 0 | 0n | \"\" | null | undefined\n): x is T => !!x;\n\nexport function isNonNullableEntry<T>(\n  entry: [key: string, value: T | null | undefined]\n): entry is [string, T] {\n  return entry[1] !== null && entry[1] !== undefined;\n}\n\ntype ReturnIfTruthy<T> = typeof isTruthy<T>;\n\nexport function assertProp<\n  T extends Record<string, unknown>,\n  K extends keyof T,\n>(obj: T, prop: K): asserts obj is T & { [P in K]-?: ReturnIfTruthy<T[P]> } {\n  assert(isTruthy(obj[prop]), `${String(prop)} is required`);\n}\n\nexport function hasCorrectAddressLength(maybeAddress: string): boolean {\n  return maybeAddress.length === 42;\n}\n\nexport const filterInvalidTokenAddress = ({\n  address,\n}: Pick<Token, \"address\">) => hasCorrectAddressLength(address);\n\nexport const stringIncludes = (a: string, b: string): boolean => {\n  return a.toLowerCase().includes(b.toLowerCase());\n};\n\n/**\n * Shorten any string with more than 6 characters (included) by inserting ellipsis placeholder in between\n *\n * @param {string} str the string to shorten\n * @param {number} start how much to leave off the start\n * @param {number} [end=0] how much to leave off the end\n * @returns {string} shortened text\n */\nexport const shortenText = (\n  str: string,\n  start: number,\n  end: number = 0\n): string => {\n  const regexp = new RegExp(`(.{${start}}).{3,}(.{${end}})`);\n  return str.replace(regexp, \"$1...$2\");\n};\n\nexport function shortenAddress(\n  address: string,\n  slashIndex = 6,\n  rightCutLength = 4\n): string {\n  // An ethereum address has 42 characters\n  return shortenText(address, slashIndex, rightCutLength);\n}\n\nexport function replaceUnderscoresWithSpaces(str: string): string {\n  return str.replace(/_/g, \" \");\n}\n"],"names":["cn","inputs","twMerge","clsx","gatherObjectsByProp","elements","pickProp","transform","reduce","accum","element","key","accumElem","transformedElement","filterUnique","constructUniqueKeys","length","hasSeen","Set","filter","keys","some","has","forEach","add","isTruthy","x","isNonNullableEntry","entry","undefined","assertProp","obj","prop","assert","String","hasCorrectAddressLength","maybeAddress","filterInvalidTokenAddress","address","stringIncludes","a","b","toLowerCase","includes","shortenText","str","start","end","regexp","RegExp","replace","shortenAddress","slashIndex","rightCutLength","replaceUnderscoresWithSpaces"],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../../../src/lib/utils/index.ts"],"sourcesContent":["import type { Token } from \"@/tokens/state/types\";\nimport { clsx, type ClassValue } from \"clsx\";\nimport { twMerge } from \"tailwind-merge\";\nimport { assert } from \"ts-essentials\";\n\nexport function cn(...inputs: ClassValue[]) {\n  return twMerge(clsx(inputs));\n}\n\n// reduce element[] to Object{key: prop, val?: element}\n// for example\n// gatherObjectsByProp(Token[], token => token.address) => Record<address, Token|undefined>\nexport function gatherObjectsByProp<T>(\n  elements: T[],\n  pickProp: (elem: T) => string\n): Record<string, T>;\nexport function gatherObjectsByProp<T, U>(\n  elements: T[],\n  pickProp: (elem: T) => string,\n  transform: (elem: T, accumElem?: U) => U\n): Record<string, U>;\nexport function gatherObjectsByProp<T, U>(\n  elements: T[],\n  pickProp: (elem: T) => string,\n  transform?: (elem: T, accumElem?: U) => U\n): Record<string, T> | Record<string, U> {\n  return elements.reduce<Record<string, T> | Record<string, U>>(\n    (accum, element) => {\n      const key = pickProp(element);\n\n      const accumElem: T | U | undefined = accum[key];\n      const transformedElement = transform\n        ? //                       if transform is available, can only be U | undefined\n          transform(element, accumElem as U | undefined)\n        : element;\n\n      accum[key] = transformedElement;\n\n      return accum;\n    },\n    {}\n  );\n}\n\nexport function filterUnique<T, U>(\n  elements: T[],\n  // supports multikey filtering, if only one key required return [U]\n  constructUniqueKeys: (element: T) => U[]\n): T[] {\n  if (elements.length <= 1) return elements;\n  const hasSeen = new Set<U>();\n\n  return elements.filter((element) => {\n    const keys = constructUniqueKeys(element);\n    if (keys.some((key) => hasSeen.has(key))) return false;\n\n    keys.forEach((key) => hasSeen.add(key));\n    return true;\n  });\n}\n\nexport const isTruthy = <T>(\n  x: T | false | 0 | 0n | \"\" | null | undefined\n): x is T => !!x;\n\nexport function isNonNullableEntry<T>(\n  entry: [key: string, value: T | null | undefined]\n): entry is [string, T] {\n  return entry[1] !== null && entry[1] !== undefined;\n}\n\ntype ReturnIfTruthy<T> = typeof isTruthy<T>;\n\nexport function assertProp<\n  T extends Record<string, unknown>,\n  K extends keyof T,\n>(obj: T, prop: K): asserts obj is T & { [P in K]-?: ReturnIfTruthy<T[P]> } {\n  assert(isTruthy(obj[prop]), `${String(prop)} is required`);\n}\n\nexport function hasCorrectAddressLength(maybeAddress: string): boolean {\n  return maybeAddress.length === 42;\n}\n\nexport const filterInvalidTokenAddress = ({\n  address,\n}: Pick<Token, \"address\">) => hasCorrectAddressLength(address);\n\nexport const stringIncludes = (a: string, b: string): boolean => {\n  return a.toLowerCase().includes(b.toLowerCase());\n};\n\n/**\n * Shorten any string with more than 6 characters (included) by inserting ellipsis placeholder in between\n *\n * @param {string} str the string to shorten\n * @param {number} start how much to leave off the start\n * @param {number} [end=0] how much to leave off the end\n * @returns {string} shortened text\n */\nexport const shortenText = (\n  str: string,\n  start: number,\n  end: number = 0\n): string => {\n  const regexp = new RegExp(`(.{${start}}).{3,}(.{${end}})`);\n  return str.replace(regexp, \"$1...$2\");\n};\n\nexport function shortenAddress(\n  address: string,\n  slashIndex = 6,\n  rightCutLength = 4\n): string {\n  // An ethereum address has 42 characters\n  return shortenText(address, slashIndex, rightCutLength);\n}\n\nexport function replaceUnderscoresWithSpaces(str: string): string {\n  return str.replace(/_/g, \" \");\n}\n\nexport function isValidUrl(url: string) {\n  try {\n    new URL(url);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport function unorderedShallowEqual<T>(a: T[], b: T[]) {\n  if (a.length !== b.length) return false;\n  const setA = new Set(a);\n  for (const item of b) {\n    if (!setA.has(item)) return false;\n  }\n  return true;\n}\n"],"names":["cn","inputs","twMerge","clsx","gatherObjectsByProp","elements","pickProp","transform","reduce","accum","element","key","accumElem","transformedElement","filterUnique","constructUniqueKeys","length","hasSeen","Set","filter","keys","some","has","forEach","add","isTruthy","x","isNonNullableEntry","entry","undefined","assertProp","obj","prop","assert","String","hasCorrectAddressLength","maybeAddress","filterInvalidTokenAddress","address","stringIncludes","a","b","toLowerCase","includes","shortenText","str","start","end","regexp","RegExp","replace","shortenAddress","slashIndex","rightCutLength","replaceUnderscoresWithSpaces","isValidUrl","url","URL","unorderedShallowEqual","setA","item"],"mappings":"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"}

package/dist/lib/web3/privy/config.js

@@ -28,7 +28,7 @@ const privyConfig = {
   },
   // another option is to give an invalid ID,
   // but then it retries indefinitely
-  walletConnectCloudProjectId: "7535ce67d223b89670980f2442899904",
+  walletConnectCloudProjectId: "9796e40630a6bea7605ac281b0deb939",
   // Privy doesn't accept const Chain[]
   supportedChains: chains
   // defaultChain: chains[0], @TODO set to App's selected chain

package/dist/lib/web3/wagmi/config.d.ts.map

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

package/dist/lib/web3/wagmi/config.js

@@ -6,7 +6,7 @@ import { isInIframe } from './isInsideSafeIframe.js';
 
 const connectors = [
   walletConnect({
-    projectId: "7535ce67d223b89670980f2442899904"
+    projectId: "9796e40630a6bea7605ac281b0deb939"
   }),
   injected(),
   // metaMask() as CreateConnectorFn, // injected() detects metamask already
@@ -21,7 +21,8 @@ if (isInIframe) {
 const wagmiConfig = createConfig({
   chains,
   connectors,
-  transports
+  transports,
+  syncConnectedChain: false
 });
 
 export { wagmiConfig };

package/dist/lib/web3/wagmi/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","sources":["../../../../src/lib/web3/wagmi/config.ts"],"sourcesContent":["import { createConfig, type CreateConnectorFn } from \"wagmi\";\nimport {\n  injected,\n  // metaMask,\n  safe,\n  walletConnect,\n  coinbaseWallet,\n} from \"wagmi/connectors\";\nimport { chains } from \"./constants\";\nimport { transports } from \"./transports\";\nimport { isInIframe } from \"./isInsideSafeIframe\";\n\n// can add more connectors to cover wallets Privy doesn't support, but need to change UI to allow connection\nconst connectors = [\n  walletConnect({\n    projectId: import.meta.env.VITE_WALLET_CONNECT_ID,\n  }) as CreateConnectorFn,\n  injected() as CreateConnectorFn,\n  // metaMask() as CreateConnectorFn, // injected() detects metamask already\n  coinbaseWallet() as CreateConnectorFn,\n  // raw returned types result in\n  // The inferred type of 'config' cannot be named without a reference to '.pnpm/@safe-global+safe-apps-provider@0.18.6_typescript@5.8.3/node_modules/@safe-global/safe-apps-provider'. This is likely not portable. A type annotation is necessary.\n\n  // getPrivyWalletConnector(), // only CorssApp Privy connector is available, not our use case\n];\n// @TODO see how we can implement Ledger connector, borrow it from rainbowkit?\n\nif (isInIframe) {\n  // when widget is in an App inside iframe, chances are we are in Safe web app,\n  // allow Safe connector to be used.\n  // we can't know if we are inside specifically Safe iframe until we try to connect, though.\n  // A check for that is in isInsideSafeIframe.ts\n  connectors.unshift(safe());\n}\n\nexport const wagmiConfig = createConfig({\n  chains,\n  connectors,\n  transports,\n});\n\ndeclare module \"wagmi\" {\n  interface Register {\n    config: typeof wagmiConfig;\n  }\n}\n"],"names":["connectors","walletConnect","projectId","import","injected","coinbaseWallet","isInIframe","unshift","safe","wagmiConfig","createConfig","chains","transports"],"mappings":";;;;;;AAaA,MAAMA,UAAAA,GAAa;AAAA,EACjBC,aAAAA,CAAc;AAAA,IACZC,SAAAA,EAAWC;AAAAA,GACZ,CAAA;AAAA,EACDC,QAAAA,EAAS;AAAA;AAAA,EAETC,cAAAA;AAAe;AAAA;AAAA;AAIf,CAAA;AAIF,IAAIC,UAAAA,EAAY;AAKdN,EAAAA,UAAAA,CAAWO,OAAAA,CAAQC,MAAM,CAAA;AAC3B;AAEO,MAAMC,cAAcC,YAAAA,CAAa;AAAA,EACtCC,MAAAA;AAAAA,EACAX,UAAAA;AAAAA,EACAY;AACF,CAAC;;;;"}
+{"version":3,"file":"config.js","sources":["../../../../src/lib/web3/wagmi/config.ts"],"sourcesContent":["import { createConfig, type CreateConnectorFn } from \"wagmi\";\nimport {\n  injected,\n  // metaMask,\n  safe,\n  walletConnect,\n  coinbaseWallet,\n} from \"wagmi/connectors\";\nimport { chains } from \"./constants\";\nimport { transports } from \"./transports\";\nimport { isInIframe } from \"./isInsideSafeIframe\";\n\n// can add more connectors to cover wallets Privy doesn't support, but need to change UI to allow connection\nconst connectors = [\n  walletConnect({\n    projectId: import.meta.env.VITE_WALLET_CONNECT_ID,\n  }) as CreateConnectorFn,\n  injected() as CreateConnectorFn,\n  // metaMask() as CreateConnectorFn, // injected() detects metamask already\n  coinbaseWallet() as CreateConnectorFn,\n  // raw returned types result in\n  // The inferred type of 'config' cannot be named without a reference to '.pnpm/@safe-global+safe-apps-provider@0.18.6_typescript@5.8.3/node_modules/@safe-global/safe-apps-provider'. This is likely not portable. A type annotation is necessary.\n\n  // getPrivyWalletConnector(), // only CorssApp Privy connector is available, not our use case\n];\n// @TODO see how we can implement Ledger connector, borrow it from rainbowkit?\n\nif (isInIframe) {\n  // when widget is in an App inside iframe, chances are we are in Safe web app,\n  // allow Safe connector to be used.\n  // we can't know if we are inside specifically Safe iframe until we try to connect, though.\n  // A check for that is in isInsideSafeIframe.ts\n  connectors.unshift(safe());\n}\n\nexport const wagmiConfig = createConfig({\n  chains,\n  connectors,\n  transports,\n  syncConnectedChain: false,\n});\n\ndeclare module \"wagmi\" {\n  interface Register {\n    config: typeof wagmiConfig;\n  }\n}\n"],"names":["connectors","walletConnect","projectId","import","injected","coinbaseWallet","isInIframe","unshift","safe","wagmiConfig","createConfig","chains","transports","syncConnectedChain"],"mappings":";;;;;;AAaA,MAAMA,UAAAA,GAAa;AAAA,EACjBC,aAAAA,CAAc;AAAA,IACZC,SAAAA,EAAWC;AAAAA,GACZ,CAAA;AAAA,EACDC,QAAAA,EAAS;AAAA;AAAA,EAETC,cAAAA;AAAe;AAAA;AAAA;AAIf,CAAA;AAIF,IAAIC,UAAAA,EAAY;AAKdN,EAAAA,UAAAA,CAAWO,OAAAA,CAAQC,MAAM,CAAA;AAC3B;AAEO,MAAMC,cAAcC,YAAAA,CAAa;AAAA,EACtCC,MAAAA;AAAAA,EACAX,UAAAA;AAAAA,EACAY,UAAAA;AAAAA,EACAC,kBAAAA,EAAoB;AACtB,CAAC;;;;"}

package/dist/lib/web3/wagmi/constants.d.ts

@@ -1,5 +1,6 @@
 import { Chain } from 'wagmi/chains';
 import { SupportedChainId } from './types';
+import { NonEmptyArray } from 'ts-essentials';
 export declare const chains: readonly [{
     blockExplorers: {
         readonly default: {
@@ -1165,7 +1166,7 @@ export declare const chains: readonly [{
         readonly transaction: typeof import('viem/chains').serializeTransactionOpStack;
     };
 }];
-export declare const supportedChainIds: (1 | 10 | 137 | 56 | 43114 | 42161 | 8453 | 100 | 146 | 130)[];
+export declare const supportedChainIds: NonEmptyArray<SupportedChainId>;
 export declare const chainConfigMap: Record<SupportedChainId, Chain & {
     id: SupportedChainId;
 }>;

package/dist/lib/web3/wagmi/constants.d.ts.map

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

package/dist/lib/web3/wagmi/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sources":["../../../../src/lib/web3/wagmi/constants.ts"],"sourcesContent":["import { type Chain } from \"wagmi/chains\";\n\nimport {\n  mainnet,\n  polygon,\n  bsc,\n  avalanche,\n  arbitrum,\n  optimism,\n  base,\n  gnosis,\n  sonic,\n  unichain,\n} from \"./supportedChains\";\n\nimport type { SupportedChainId } from \"./types\";\n\nexport const chains = [\n  mainnet,\n  polygon,\n  bsc,\n  avalanche,\n  arbitrum,\n  optimism,\n  base,\n  gnosis,\n  sonic,\n  unichain,\n] as const;\n\nexport const supportedChainIds = chains.map((chain) => chain.id);\n\nexport const chainConfigMap: Record<\n  SupportedChainId,\n  Chain & { id: SupportedChainId }\n> = {\n  [mainnet.id]: mainnet,\n  [polygon.id]: polygon,\n  [bsc.id]: bsc,\n  [avalanche.id]: avalanche,\n  [arbitrum.id]: arbitrum,\n  [optimism.id]: optimism,\n  [base.id]: base,\n  [gnosis.id]: gnosis,\n  [sonic.id]: sonic,\n  [unichain.id]: unichain,\n};\n"],"names":["chains","mainnet","polygon","bsc","avalanche","arbitrum","optimism","base","gnosis","sonic","unichain","supportedChainIds","map","chain","id","chainConfigMap"],"mappings":";;AAiBO,MAAMA,MAAAA,GAAS,CACpBC,OAAAA,EACAC,OAAAA,EACAC,GAAAA,EACAC,SAAAA,EACAC,QAAAA,EACAC,QAAAA,EACAC,IAAAA,EACAC,MAAAA,EACAC,KAAAA,EACAC,QAAQ;AAGH,MAAMC,iBAAAA,GAAoBX,MAAAA,CAAOY,GAAAA,CAAKC,CAAAA,KAAAA,KAAUA,MAAMC,EAAE;AAExD,MAAMC,cAAAA,GAGT;AAAA,EACF,CAACd,OAAAA,CAAQa,EAAE,GAAGb,OAAAA;AAAAA,EACd,CAACC,OAAAA,CAAQY,EAAE,GAAGZ,OAAAA;AAAAA,EACd,CAACC,GAAAA,CAAIW,EAAE,GAAGX,GAAAA;AAAAA,EACV,CAACC,SAAAA,CAAUU,EAAE,GAAGV,SAAAA;AAAAA,EAChB,CAACC,QAAAA,CAASS,EAAE,GAAGT,QAAAA;AAAAA,EACf,CAACC,QAAAA,CAASQ,EAAE,GAAGR,QAAAA;AAAAA,EACf,CAACC,IAAAA,CAAKO,EAAE,GAAGP,IAAAA;AAAAA,EACX,CAACC,MAAAA,CAAOM,EAAE,GAAGN,MAAAA;AAAAA,EACb,CAACC,KAAAA,CAAMK,EAAE,GAAGL,KAAAA;AAAAA,EACZ,CAACC,QAAAA,CAASI,EAAE,GAAGJ;AACjB;;;;"}
+{"version":3,"file":"constants.js","sources":["../../../../src/lib/web3/wagmi/constants.ts"],"sourcesContent":["import { type Chain } from \"wagmi/chains\";\n\nimport {\n  mainnet,\n  polygon,\n  bsc,\n  avalanche,\n  arbitrum,\n  optimism,\n  base,\n  gnosis,\n  sonic,\n  unichain,\n} from \"./supportedChains\";\n\nimport type { SupportedChainId } from \"./types\";\nimport type { NonEmptyArray } from \"ts-essentials\";\n\nexport const chains = [\n  mainnet,\n  polygon,\n  bsc,\n  avalanche,\n  arbitrum,\n  optimism,\n  base,\n  gnosis,\n  sonic,\n  unichain,\n] as const;\n\nexport const supportedChainIds = chains.map(\n  (chain) => chain.id\n) as NonEmptyArray<SupportedChainId>;\n\nexport const chainConfigMap: Record<\n  SupportedChainId,\n  Chain & { id: SupportedChainId }\n> = {\n  [mainnet.id]: mainnet,\n  [polygon.id]: polygon,\n  [bsc.id]: bsc,\n  [avalanche.id]: avalanche,\n  [arbitrum.id]: arbitrum,\n  [optimism.id]: optimism,\n  [base.id]: base,\n  [gnosis.id]: gnosis,\n  [sonic.id]: sonic,\n  [unichain.id]: unichain,\n};\n"],"names":["chains","mainnet","polygon","bsc","avalanche","arbitrum","optimism","base","gnosis","sonic","unichain","supportedChainIds","map","chain","id","chainConfigMap"],"mappings":";;AAkBO,MAAMA,MAAAA,GAAS,CACpBC,OAAAA,EACAC,OAAAA,EACAC,GAAAA,EACAC,SAAAA,EACAC,QAAAA,EACAC,QAAAA,EACAC,IAAAA,EACAC,MAAAA,EACAC,KAAAA,EACAC,QAAQ;AAGH,MAAMC,iBAAAA,GAAoBX,MAAAA,CAAOY,GAAAA,CACrCC,CAAAA,KAAAA,KAAUA,MAAMC,EACnB;AAEO,MAAMC,cAAAA,GAGT;AAAA,EACF,CAACd,OAAAA,CAAQa,EAAE,GAAGb,OAAAA;AAAAA,EACd,CAACC,OAAAA,CAAQY,EAAE,GAAGZ,OAAAA;AAAAA,EACd,CAACC,GAAAA,CAAIW,EAAE,GAAGX,GAAAA;AAAAA,EACV,CAACC,SAAAA,CAAUU,EAAE,GAAGV,SAAAA;AAAAA,EAChB,CAACC,QAAAA,CAASS,EAAE,GAAGT,QAAAA;AAAAA,EACf,CAACC,QAAAA,CAASQ,EAAE,GAAGR,QAAAA;AAAAA,EACf,CAACC,IAAAA,CAAKO,EAAE,GAAGP,IAAAA;AAAAA,EACX,CAACC,MAAAA,CAAOM,EAAE,GAAGN,MAAAA;AAAAA,EACb,CAACC,KAAAA,CAAMK,EAAE,GAAGL,KAAAA;AAAAA,EACZ,CAACC,QAAAA,CAASI,EAAE,GAAGJ;AACjB;;;;"}