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

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

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

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

@@ -0,0 +1,75 @@
+import { d as distExports } from '../../../_virtual/index.js';
+import { ensureTxResponseFactory } from '../../../transactions/queries/ensureTxResponse.js';
+import { useQueryClient } from '@tanstack/react-query';
+import { useTransaction, useConfig } from 'wagmi';
+
+function useEnsureTxResponse() {
+  const $ = distExports.c(3);
+  const queryClient = useQueryClient();
+  const wagmiConfig = useConfig();
+  let t0;
+  if ($[0] !== queryClient || $[1] !== wagmiConfig) {
+    t0 = ensureTxResponseFactory({
+      queryClient,
+      wagmiConfig
+    });
+    $[0] = queryClient;
+    $[1] = wagmiConfig;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+}
+function useTxResponse(t0) {
+  const $ = distExports.c(9);
+  const {
+    hash,
+    chainId,
+    enabled: t1
+  } = t0;
+  const enabled = t1 === void 0 ? true : t1;
+  const ensureTxResponse = useEnsureTxResponse();
+  const t2 = !!hash && enabled;
+  let t3;
+  if ($[0] !== t2) {
+    t3 = {
+      enabled: t2
+    };
+    $[0] = t2;
+    $[1] = t3;
+  } else {
+    t3 = $[1];
+  }
+  let t4;
+  if ($[2] !== chainId || $[3] !== hash || $[4] !== t3) {
+    t4 = {
+      hash,
+      chainId,
+      query: t3
+    };
+    $[2] = chainId;
+    $[3] = hash;
+    $[4] = t3;
+    $[5] = t4;
+  } else {
+    t4 = $[5];
+  }
+  const txResponseQuery = useTransaction(t4);
+  let t5;
+  if ($[6] !== ensureTxResponse || $[7] !== txResponseQuery) {
+    t5 = {
+      query: txResponseQuery,
+      ensureTxResponse
+    };
+    $[6] = ensureTxResponse;
+    $[7] = txResponseQuery;
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  return t5;
+}
+
+export { useEnsureTxResponse, useTxResponse };
+//# sourceMappingURL=useTxResponse.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTxResponse.js","sources":["../../../../src/hooks/txs/queries/useTxResponse.ts"],"sourcesContent":["import type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport {\n  ensureTxResponseFactory,\n  type EnsureTxResponseFn,\n} from \"@/transactions/queries/ensureTxResponse\";\nimport { useQueryClient } from \"@tanstack/react-query\";\nimport type { Hash } from \"viem\";\nimport { useConfig, useTransaction } from \"wagmi\";\n\nexport function useEnsureTxResponse(): EnsureTxResponseFn {\n  const queryClient = useQueryClient();\n  const wagmiConfig = useConfig();\n\n  return ensureTxResponseFactory({ queryClient, wagmiConfig });\n}\n\ntype UseTxResponseInput = {\n  hash?: Hash;\n  chainId?: SupportedChainId;\n  enabled?: boolean;\n};\n\nexport function useTxResponse({\n  hash,\n  chainId,\n  enabled = true,\n}: UseTxResponseInput) {\n  const ensureTxResponse = useEnsureTxResponse();\n\n  const txResponseQuery = useTransaction({\n    hash,\n    chainId,\n    query: { enabled: !!hash && enabled },\n  });\n\n  return {\n    query: txResponseQuery,\n    ensureTxResponse,\n  };\n}\n"],"names":["useEnsureTxResponse","$","_c","queryClient","useQueryClient","wagmiConfig","useConfig","t0","ensureTxResponseFactory","useTxResponse","hash","chainId","enabled","t1","undefined","ensureTxResponse","t2","t3","t4","query","txResponseQuery","useTransaction","t5"],"mappings":";;;;;AASO,SAAAA,mBAAAA,GAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACL,EAAA,MAAAC,cAAoBC,cAAAA,EAAe;AACnC,EAAA,MAAAC,cAAoBC,SAAAA,EAAU;AAAE,EAAA,IAAAC,EAAAA;AAAA,EAAA,IAAAN,EAAA,CAAA,CAAA,KAAAE,eAAAF,CAAAA,QAAAI,WAAAA,EAAA;AAEzBE,IAAAA,EAAAA,GAAAC,uBAAAA,CAAwB;AAAA,MAAAL,WAAAA;AAAAA,MAAAE;AAAAA,KAA4B,CAAA;AAACJ,IAAAA,CAAAA,MAAAE,WAAAA;AAAAF,IAAAA,CAAAA,MAAAI,WAAAA;AAAAJ,IAAAA,CAAAA,MAAAM,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAN,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAArDM,EAAAA;AAAqD;AASvD,SAAAE,cAAAF,EAAAA,EAAA;AAAA,EAAA,MAAAN,CAAAA,GAAAC,cAAA,CAAA,CAAA;AAAuB,EAAA,MAAA;AAAA,IAAAQ,IAAAA;AAAAA,IAAAC,OAAAA;AAAAA,IAAAC,OAAAA,EAAAC;AAAAA,GAAA,GAAAN,EAAAA;AAG5B,EAAA,MAAAK,OAAAA,GAAAC,EAAAA,KAAAC,MAAAA,GAAA,IAAA,GAAAD,EAAAA;AAEA,EAAA,MAAAE,mBAAyBf,mBAAAA,EAAoB;AAKzB,EAAA,MAAAgB,EAAAA,GAAA,CAAC,CAACN,IAAAA,IAAFE,OAAAA;AAAiB,EAAA,IAAAK,EAAAA;AAAA,EAAA,IAAAhB,CAAAA,QAAAe,EAAAA,EAAA;AAA5BC,IAAAA,EAAAA,GAAA;AAAA,MAAAL,OAAAA,EAAWI;AAAAA,KAAkB;AAACf,IAAAA,CAAAA,MAAAe,EAAAA;AAAAf,IAAAA,CAAAA,MAAAgB,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAhB,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,IAAAiB,EAAAA;AAAA,EAAA,IAAAjB,CAAAA,CAAA,CAAA,CAAA,KAAAU,OAAAA,IAAAV,CAAAA,QAAAS,IAAAA,IAAAT,CAAAA,CAAA,CAAA,CAAA,KAAAgB,EAAAA,EAAA;AAHAC,IAAAA,EAAAA,GAAA;AAAA,MAAAR,IAAAA;AAAAA,MAAAC,OAAAA;AAAAA,MAAAQ,KAAAA,EAG9BF;AAAAA,KACT;AAAChB,IAAAA,CAAAA,MAAAU,OAAAA;AAAAV,IAAAA,CAAAA,MAAAS,IAAAA;AAAAT,IAAAA,CAAAA,MAAAgB,EAAAA;AAAAhB,IAAAA,CAAAA,MAAAiB,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAjB,EAAA,CAAA,CAAA;AAAA,EAAA;AAJD,EAAA,MAAAmB,eAAAA,GAAwBC,eAAeH,EAItC,CAAA;AAAE,EAAA,IAAAI,EAAAA;AAAA,EAAA,IAAArB,EAAA,CAAA,CAAA,KAAAc,oBAAAd,CAAAA,QAAAmB,eAAAA,EAAA;AAEIE,IAAAA,EAAAA,GAAA;AAAA,MAAAH,KAAAA,EACEC,eAAAA;AAAAA,MAAeL;AAAAA,KAExB;AAACd,IAAAA,CAAAA,MAAAc,gBAAAA;AAAAd,IAAAA,CAAAA,MAAAmB,eAAAA;AAAAnB,IAAAA,CAAAA,MAAAqB,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAArB,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAHMqB,EAAAA;AAGN;;;;"}

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

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

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

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

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

@@ -0,0 +1,30 @@
+import { d as distExports } from '../../../_virtual/index.js';
+import { useAccount } from 'wagmi';
+import { useWalletMetadata } from '../../../components/web3/ConnectWallets/walletIcons.js';
+import { useIsAccountContract } from '../../getCode/useIsAccountContract.js';
+
+const SUPPORTED_WALLETS_REGEX = /Rabby|Ledger Wallet/i;
+function useWalletCanReplaceTx() {
+  const $ = distExports.c(2);
+  const {
+    connector
+  } = useAccount();
+  const walletMetadata = useWalletMetadata(connector);
+  const {
+    data: accountContractData
+  } = useIsAccountContract();
+  let t0;
+  if ($[0] !== walletMetadata) {
+    t0 = !!walletMetadata?.name && !SUPPORTED_WALLETS_REGEX.test(walletMetadata.name);
+    $[0] = walletMetadata;
+    $[1] = t0;
+  } else {
+    t0 = $[1];
+  }
+  const isKnownUnsupportedWallet = t0;
+  const isSmartContract = accountContractData?.isContract ?? false;
+  return !!connector && !!walletMetadata && !isKnownUnsupportedWallet && !isSmartContract;
+}
+
+export { useWalletCanReplaceTx };
+//# sourceMappingURL=useWalletCanReplaceTx.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useWalletCanReplaceTx.js","sources":["../../../../src/hooks/txs/queries/useWalletCanReplaceTx.ts"],"sourcesContent":["import { useAccount } from \"wagmi\";\nimport { useWalletMetadata } from \"@/components/web3/ConnectWallets/walletIcons\";\nimport { useIsAccountContract } from \"@/hooks/getCode/useIsAccountContract\";\n/**\n * Some of the tested wallets:\n *\n * | Wallet        | Test result                                                                                              | Supports | metadata.name |\n * | ------------- | -------------------------------------------------------------------------------------------------------- | -------- | ------------- |\n * | Rabby         | Works, but ignores gasPrice params                                                                       | ✓        | Rabby Wallet  |\n * | MetaMask      | nonce is ignored, gasPrice params accepted                                                               | ✗        | MetaMask      |\n * | TrustWallet   | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Trust Wallet  |\n * | BitGet Wallet | ignores gasPrice params, accepts nonce, but doesn't allow to submit tx with same nonce to replace        | ✗        | Bitget Wallet |\n * | Rainbow       | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Rainbow       |\n * | Phantom       | accepts nonce, but doesn't allow to submit tx with same nonce to replace, ignores gasPrice params        | ✗        | Phantom       |\n * | Enkrypt       | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Enkrypt       |\n * | Ledger Live   | ignores nonce, uses its internal nonce, ignores gasPrice params                                          | ✗        | Ledger Live   |\n * | Ledger Button | supports nonce, should take all params as is                                                             | ✓        | Ledger Wallet |\n *\n */\n\nconst SUPPORTED_WALLETS_REGEX = /Rabby|Ledger Wallet/i; // wallets known to support replaceTx nonce override\n\nexport function useWalletCanReplaceTx(): boolean {\n  const { connector } = useAccount();\n  const walletMetadata = useWalletMetadata(connector);\n  const { data: accountContractData } = useIsAccountContract();\n\n  // 1. Check if Wallet is Metamask (injected wallet or through WalletConnect)\n  // Metamask ignores txParams.nonce and doesn't allow replacing txs\n  const isKnownUnsupportedWallet =\n    !!walletMetadata?.name &&\n    !SUPPORTED_WALLETS_REGEX.test(walletMetadata.name);\n\n  // 2. Check if user account is a SmartContract\n  // SmartContracts have their own logic for replacing pending txs (if any)\n  const isSmartContract = accountContractData?.isContract ?? false;\n\n  return (\n    !!connector &&\n    !!walletMetadata &&\n    !isKnownUnsupportedWallet &&\n    !isSmartContract\n  );\n}\n"],"names":["SUPPORTED_WALLETS_REGEX","useWalletCanReplaceTx","$","_c","connector","useAccount","walletMetadata","useWalletMetadata","data","accountContractData","useIsAccountContract","t0","name","test","isKnownUnsupportedWallet","isSmartContract","isContract"],"mappings":";;;;;AAoBA,MAAMA,uBAAAA,GAA0B,sBAAA;AAEzB,SAAAC,qBAAAA,GAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACL,EAAA,MAAA;AAAA,IAAAC;AAAAA,MAAsBC,UAAAA,EAAW;AACjC,EAAA,MAAAC,cAAAA,GAAuBC,kBAAkBH,SAAS,CAAA;AAClD,EAAA,MAAA;AAAA,IAAAI,IAAAA,EAAAC;AAAAA,MAAsCC,oBAAAA,EAAqB;AAAE,EAAA,IAAAC,EAAAA;AAAA,EAAA,IAAAT,CAAAA,QAAAI,cAAAA,EAAA;AAK3DK,IAAAA,EAAAA,GAAA,CAAC,CAACL,cAAAA,EAAcM,IAAAA,IAAhB,CACCZ,uBAAAA,CAAuBa,IAAAA,CAAMP,eAAcM,IAAK,CAAA;AAACV,IAAAA,CAAAA,MAAAI,cAAAA;AAAAJ,IAAAA,CAAAA,MAAAS,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAT,EAAA,CAAA,CAAA;AAAA,EAAA;AAFpD,EAAA,MAAAY,wBAAAA,GACEH,EAAAA;AAKF,EAAA,MAAAI,eAAAA,GAAwBN,qBAAmBO,UAAAA,IAAnB,KAAA;AAAyC,EAAA,OAG/D,CAAC,CAACZ,SAAAA,IAAF,CACC,CAACE,cAAAA,IADF,CAECQ,4BAFD,CAGCC,eAAAA;AAAe;;;;"}

package/dist/index.d.ts

@@ -4,7 +4,7 @@ export type { SupportedChainId } from './lib/web3/wagmi/types';
 export type { SwapMode } from './components/widget/SwapModeSwitcher/state/types';
 export type { MinTradeFlowToken } from './components/widget/TradeOverview';
 export type { LimitOrderFormState, TwapFormState, OTCOrderFormState, SwapFormState, SettingsState, TokenFormState, WidgetState, AccountState, } from './events/types/common';
-export type { WidgetEventCallbacks, OnConnectWallet, OnAllowToken, OnWrapETH, OnSwap, OnTwapOrder, OnLimitOrder, OnOTCOrder, OnSettingsChange, OnCancelOrder, OnFillOTCOrder, OnFormInputChange, OnPriceChange, } from './events/types';
+export type { WidgetEventCallbacks, OnConnectWallet, OnAllowToken, OnWrapETH, OnSwap, OnTwapOrder, OnLimitOrder, OnOTCOrder, OnSettingsChange, OnCancelOrder, OnCancelTx, OnFillOTCOrder, OnFormInputChange, OnPriceChange, } from './events/types';
 export type { FormInputProps } from './core/inputs/state/types';
 export type { TradeMode } from './core/state/tradeModeAtom';
 export { defaults } from './core/constants';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"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,cAAc,EACd,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,YAAY,EAAE,QAAQ,EAAE,MAAM,kDAAkD,CAAC;AACjF,YAAY,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,YAAY,EACV,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,EACX,YAAY,GACb,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,SAAS,EACT,MAAM,EACN,WAAW,EACX,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,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,cAAc,EACd,kBAAkB,GACnB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,YAAY,EAAE,QAAQ,EAAE,MAAM,kDAAkD,CAAC;AACjF,YAAY,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,YAAY,EACV,mBAAmB,EACnB,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,aAAa,EACb,cAAc,EACd,WAAW,EACX,YAAY,GACb,MAAM,uBAAuB,CAAC;AAC/B,YAAY,EACV,oBAAoB,EACpB,eAAe,EACf,YAAY,EACZ,SAAS,EACT,MAAM,EACN,WAAW,EACX,YAAY,EACZ,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,UAAU,EACV,cAAc,EACd,iBAAiB,EACjB,aAAa,GACd,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAChE,YAAY,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAG5D,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC"}

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

@@ -1,6 +1,6 @@
 import { Token } from '../../tokens/state/types';
 import { ClassValue } from 'clsx';
-import { MergeN } from 'ts-essentials';
+import { Prettify } from 'ts-essentials';
 export declare function cn(...inputs: ClassValue[]): string;
 export declare function gatherObjectsByProp<T>(elements: T[], pickProp: (elem: T) => string): Record<string, T>;
 export declare function gatherObjectsByProp<T, U>(elements: T[], pickProp: (elem: T) => string, transform: (elem: T, accumElem?: U) => U): Record<string, U>;
@@ -8,8 +8,22 @@ type RemoveNullableElements<T extends readonly unknown[]> = T extends readonly [
     infer Head,
     ...infer Tail
 ] ? Head extends undefined | null ? RemoveNullableElements<Tail> : [Head, ...RemoveNullableElements<Tail>] : [];
-type MergeWithoutNullable<Tuple extends readonly unknown[]> = MergeN<RemoveNullableElements<Tuple>>;
-export declare function concatClassNamesMaps<T extends (Record<string, string | undefined> | undefined)[]>(...maps: T): MergeWithoutNullable<T>;
+type MergeRecordsWithStrings<R1 extends Record<string, string>, R2 extends Record<string, string>> = {
+    [K in keyof R1 | keyof R2]: K extends keyof R1 ? K extends keyof R2 ? ConcatString<" ", [R1[K], R2[K]]> : R1[K] : K extends keyof R2 ? R2[K] : never;
+};
+type _ConcatString<Delim extends string, Parts extends readonly string[]> = Parts extends readonly [] ? "" : Parts extends readonly [
+    infer Head extends string,
+    ...infer Tail extends readonly string[]
+] ? Tail extends readonly [] ? Head : `${Head}${Delim}${_ConcatString<Delim, Tail>}` : never;
+export type ConcatString<Delim extends string = "", Parts extends readonly string[] = []> = _ConcatString<Delim, Parts>;
+type RecordOfStrings = Record<string, string>;
+type _MergeNStrings<Tuple extends readonly RecordOfStrings[], Result extends RecordOfStrings> = Tuple extends readonly [
+    infer Head extends RecordOfStrings,
+    ...infer Tail extends readonly RecordOfStrings[]
+] ? _MergeNStrings<Tail, MergeRecordsWithStrings<Result, Head>> : Result;
+type MergeNStrings<Tuple extends readonly RecordOfStrings[]> = _MergeNStrings<Tuple, {}>;
+type MergeWithoutNullable<Tuple extends readonly (RecordOfStrings | undefined | null)[]> = MergeNStrings<RemoveNullableElements<Tuple>>;
+export declare function concatClassNamesMaps<T extends readonly (RecordOfStrings | undefined | null)[]>(...maps: T): Prettify<MergeWithoutNullable<T>>;
 export declare function filterUnique<T, U>(elements: T[], constructUniqueKeys: (element: T) => U[]): T[];
 export declare const isTruthy: <T>(x: T | false | 0 | 0n | "" | null | undefined) => x is T;
 export declare function isNonNullableEntry<T>(entry: [key: string, value: T | null | undefined]): entry is [string, T];

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":"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"}
+{"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;AAE7C,OAAO,EAAU,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEtD,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,KAAK,sBAAsB,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI,CAAC,SAAS,SAAS;IAC7E,MAAM,IAAI;IACV,GAAG,MAAM,IAAI;CACd,GACG,IAAI,SAAS,SAAS,GAAG,IAAI,GAC3B,sBAAsB,CAAC,IAAI,CAAC,GAC5B,CAAC,IAAI,EAAE,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC,GACzC,EAAE,CAAC;AAEP,KAAK,uBAAuB,CAC1B,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EACjC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,IAC/B;KACD,CAAC,IAAI,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,CAAC,SAAS,MAAM,EAAE,GAC1C,CAAC,SAAS,MAAM,EAAE,GAChB,YAAY,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GACjC,EAAE,CAAC,CAAC,CAAC,GACP,CAAC,SAAS,MAAM,EAAE,GAChB,EAAE,CAAC,CAAC,CAAC,GACL,KAAK;CACZ,CAAC;AAEF,KAAK,aAAa,CAChB,KAAK,SAAS,MAAM,EACpB,KAAK,SAAS,SAAS,MAAM,EAAE,IAC7B,KAAK,SAAS,SAAS,EAAE,GACzB,EAAE,GACF,KAAK,SAAS,SAAS;IACnB,MAAM,IAAI,SAAS,MAAM;IACzB,GAAG,MAAM,IAAI,SAAS,SAAS,MAAM,EAAE;CACxC,GACD,IAAI,SAAS,SAAS,EAAE,GACtB,IAAI,GACJ,GAAG,IAAI,GAAG,KAAK,GAAG,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,GAChD,KAAK,CAAC;AAEZ,MAAM,MAAM,YAAY,CACtB,KAAK,SAAS,MAAM,GAAG,EAAE,EACzB,KAAK,SAAS,SAAS,MAAM,EAAE,GAAG,EAAE,IAClC,aAAa,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAEhC,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAE9C,KAAK,cAAc,CACjB,KAAK,SAAS,SAAS,eAAe,EAAE,EACxC,MAAM,SAAS,eAAe,IAC5B,KAAK,SAAS,SAAS;IACzB,MAAM,IAAI,SAAS,eAAe;IAClC,GAAG,MAAM,IAAI,SAAS,SAAS,eAAe,EAAE;CACjD,GACG,cAAc,CAAC,IAAI,EAAE,uBAAuB,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,GAC3D,MAAM,CAAC;AACX,KAAK,aAAa,CAAC,KAAK,SAAS,SAAS,eAAe,EAAE,IAAI,cAAc,CAC3E,KAAK,EAEL,EAAE,CACH,CAAC;AAEF,KAAK,oBAAoB,CACvB,KAAK,SAAS,SAAS,CAAC,eAAe,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,IAC3D,aAAa,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,CAAC;AAEjD,wBAAgB,oBAAoB,CAClC,CAAC,SAAS,SAAS,CAAC,eAAe,GAAG,SAAS,GAAG,IAAI,CAAC,EAAE,EACzD,GAAG,IAAI,EAAE,CAAC,GAAG,QAAQ,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAkB/C;AAED,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,GAAG,OAAO,CAO/C;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,OAAO,CAOhE;AAED,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,MAAM,EACvD,UAAU,EAAE,SAAS,CAAC,EAAE,GACvB,CAAC,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,KAAK,OAAO,CAI7E;AAED,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAuBnD;AAED,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,MAAM,CAER"}

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, type MergeN } 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\ntype RemoveNullableElements<T extends readonly unknown[]> = T extends readonly [\n  infer Head,\n  ...infer Tail,\n]\n  ? Head extends undefined | null\n    ? RemoveNullableElements<Tail>\n    : [Head, ...RemoveNullableElements<Tail>]\n  : [];\n\ntype MergeWithoutNullable<Tuple extends readonly unknown[]> = MergeN<\n  RemoveNullableElements<Tuple>\n>;\n\nexport function concatClassNamesMaps<\n  T extends (Record<string, string | undefined> | undefined)[],\n>(...maps: T): MergeWithoutNullable<T> {\n  if (maps.length <= 1) return (maps[0] || {}) as MergeWithoutNullable<T>;\n\n  const gathered: Record<string, string> = {};\n\n  for (const map of maps) {\n    if (!map) continue;\n\n    for (const key in map) {\n      const value = map[key];\n      if (value !== undefined) {\n        gathered[key] = cn(gathered[key], value);\n      }\n    }\n  }\n\n  return gathered as MergeWithoutNullable<T>;\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): boolean {\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[]): boolean {\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\nexport function constructPropertiesEqual<K extends string>(\n  properties: readonly K[]\n): (a: Partial<Record<K, unknown>>, b: Partial<Record<K, unknown>>) => boolean {\n  return (a, b) => {\n    return properties.every((key) => a[key] === b[key]);\n  };\n}\n\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  // both the same value, check would pass for primitive values\n  if (a === b) {\n    return true;\n  }\n\n  // not an object, and checks for primitive have already been made\n  if (typeof a !== \"object\" || typeof b !== \"object\" || !a || !b) {\n    return false;\n  }\n  // both objects, check if they have the same keys\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  // different number of keys\n  if (aKeys.length !== bKeys.length) {\n    return false;\n  }\n  return aKeys.every(\n    (key) =>\n      // b[key] exists, and not a[key] === undefined && b[key] doesn't exist\n      Object.prototype.hasOwnProperty.call(b, key) &&\n      a[key as keyof typeof a] === b[key as keyof typeof b]\n  );\n}\n\nexport function getNumberWithinRange(\n  num: number,\n  min: number,\n  max: number\n): number {\n  return Math.min(Math.max(num, min), max);\n}\n"],"names":["cn","inputs","twMerge","clsx","gatherObjectsByProp","elements","pickProp","transform","reduce","accum","element","key","accumElem","transformedElement","concatClassNamesMaps","maps","length","gathered","map","value","undefined","filterUnique","constructUniqueKeys","hasSeen","Set","filter","keys","some","has","forEach","add","isTruthy","x","isNonNullableEntry","entry","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","constructPropertiesEqual","properties","every","shallowEqual","aKeys","Object","bKeys","prototype","hasOwnProperty","call","getNumberWithinRange","num","min","max","Math"],"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, type Prettify } 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\ntype RemoveNullableElements<T extends readonly unknown[]> = T extends readonly [\n  infer Head,\n  ...infer Tail,\n]\n  ? Head extends undefined | null\n    ? RemoveNullableElements<Tail>\n    : [Head, ...RemoveNullableElements<Tail>]\n  : [];\n\ntype MergeRecordsWithStrings<\n  R1 extends Record<string, string>,\n  R2 extends Record<string, string>,\n> = {\n  [K in keyof R1 | keyof R2]: K extends keyof R1\n    ? K extends keyof R2\n      ? ConcatString<\" \", [R1[K], R2[K]]>\n      : R1[K]\n    : K extends keyof R2\n      ? R2[K]\n      : never;\n};\n\ntype _ConcatString<\n  Delim extends string,\n  Parts extends readonly string[],\n> = Parts extends readonly []\n  ? \"\"\n  : Parts extends readonly [\n        infer Head extends string,\n        ...infer Tail extends readonly string[],\n      ]\n    ? Tail extends readonly []\n      ? Head\n      : `${Head}${Delim}${_ConcatString<Delim, Tail>}`\n    : never;\n\nexport type ConcatString<\n  Delim extends string = \"\",\n  Parts extends readonly string[] = [],\n> = _ConcatString<Delim, Parts>;\n\ntype RecordOfStrings = Record<string, string>;\n\ntype _MergeNStrings<\n  Tuple extends readonly RecordOfStrings[],\n  Result extends RecordOfStrings,\n> = Tuple extends readonly [\n  infer Head extends RecordOfStrings,\n  ...infer Tail extends readonly RecordOfStrings[],\n]\n  ? _MergeNStrings<Tail, MergeRecordsWithStrings<Result, Head>>\n  : Result;\ntype MergeNStrings<Tuple extends readonly RecordOfStrings[]> = _MergeNStrings<\n  Tuple,\n  // eslint-disable-next-line @typescript-eslint/no-empty-object-type\n  {}\n>;\n\ntype MergeWithoutNullable<\n  Tuple extends readonly (RecordOfStrings | undefined | null)[],\n> = MergeNStrings<RemoveNullableElements<Tuple>>;\n\nexport function concatClassNamesMaps<\n  T extends readonly (RecordOfStrings | undefined | null)[],\n>(...maps: T): Prettify<MergeWithoutNullable<T>> {\n  if (maps.length <= 1)\n    return (maps[0] || {}) as Prettify<MergeWithoutNullable<T>>;\n\n  const gathered: Record<string, string> = {};\n\n  for (const map of maps) {\n    if (!map) continue;\n\n    for (const key in map) {\n      const value = map[key];\n      if (value !== undefined) {\n        gathered[key] = cn(gathered[key], value);\n      }\n    }\n  }\n\n  return gathered as Prettify<MergeWithoutNullable<T>>;\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): boolean {\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[]): boolean {\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\nexport function constructPropertiesEqual<K extends string>(\n  properties: readonly K[]\n): (a: Partial<Record<K, unknown>>, b: Partial<Record<K, unknown>>) => boolean {\n  return (a, b) => {\n    return properties.every((key) => a[key] === b[key]);\n  };\n}\n\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  // both the same value, check would pass for primitive values\n  if (a === b) {\n    return true;\n  }\n\n  // not an object, and checks for primitive have already been made\n  if (typeof a !== \"object\" || typeof b !== \"object\" || !a || !b) {\n    return false;\n  }\n  // both objects, check if they have the same keys\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  // different number of keys\n  if (aKeys.length !== bKeys.length) {\n    return false;\n  }\n  return aKeys.every(\n    (key) =>\n      // b[key] exists, and not a[key] === undefined && b[key] doesn't exist\n      Object.prototype.hasOwnProperty.call(b, key) &&\n      a[key as keyof typeof a] === b[key as keyof typeof b]\n  );\n}\n\nexport function getNumberWithinRange(\n  num: number,\n  min: number,\n  max: number\n): number {\n  return Math.min(Math.max(num, min), max);\n}\n"],"names":["cn","inputs","twMerge","clsx","gatherObjectsByProp","elements","pickProp","transform","reduce","accum","element","key","accumElem","transformedElement","concatClassNamesMaps","maps","length","gathered","map","value","undefined","filterUnique","constructUniqueKeys","hasSeen","Set","filter","keys","some","has","forEach","add","isTruthy","x","isNonNullableEntry","entry","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","constructPropertiesEqual","properties","every","shallowEqual","aKeys","Object","bKeys","prototype","hasOwnProperty","call","getNumberWithinRange","num","min","max","Math"],"mappings":"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"}

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

@@ -16,7 +16,6 @@ export declare function applySlippage({ srcAmount, destAmount, }: Pick<DeltaOrMa
  * Calculates the destination amount after applying partner fee.
  *
  * @param price - The DeltaOrMarketPrice object containing destAmounts and partnerFee.
- * @param priceMode - The mode of the price, either "delta" or "market".
  * @returns The destination amount after applying partner fee.
  */
 export declare function getDestAmountAfterFee(price: DeltaOrMarketPrice): 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;;;;;;GAMG;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,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"}

package/dist/lib/utils/price.js

@@ -21,10 +21,8 @@ function applySlippage({
   };
 }
 function getDestAmountAfterFee(price) {
-  if (isDeltaPrice(price)) {
-    return price.receivedDestAmount;
-  }
-  return subtractFee(price.destAmount, price.partnerFee);
+  const destAmount = isDeltaPrice(price) ? price.receivedDestAmount : price.destAmount;
+  return subtractFee(destAmount, price.partnerFee);
 }
 function getDestAmountAfterFeeAndSlippage({
   price,

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

@@ -1 +1 @@
-{"version":3,"file":"price.js","sources":["../../../src/lib/utils/price.ts"],"sourcesContent":["import type { DeltaOrMarketPrice } from \"@/hooks/swap/prices/types\";\nimport { amountAfterSlippage, subtractSlippage } from \"./slippage\";\nimport { subtractFee } from \"./fee\";\nimport Big from \"big.js\";\nimport { isDeltaPrice } from \"@/hooks/swap/prices/delta/queries/useDeltaPriceQuery\";\n\n/**\n * Applies slippage to the srcAmount and destAmount of a DeltaOrMarketPrice.\n *\n * @param srcAmount - The source amount of the trade.\n * @param destAmount - The destination amount of the trade.\n * @param slippage - The slippage percentage to apply (e.g., 0.5 for 0.5%).\n * @param side - The side of the trade, either \"BUY\" or \"SELL\".\n * @returns An object containing the adjusted srcAmount and destAmount after applying slippage.\n */\nexport function applySlippage(\n  {\n    srcAmount,\n    destAmount,\n  }: Pick<DeltaOrMarketPrice, \"srcAmount\" | \"destAmount\">,\n  slippage: number,\n  side: \"BUY\" | \"SELL\"\n) {\n  if (side === \"BUY\") {\n    const srcAmountAfterSlippage = amountAfterSlippage(\n      srcAmount,\n      slippage,\n      side\n    ).toFixed(0);\n\n    return {\n      srcAmount: srcAmountAfterSlippage,\n      destAmount,\n    };\n  }\n\n  const destAmountAfterSlippage = amountAfterSlippage(\n    destAmount,\n    slippage,\n    side\n  ).toFixed(0);\n\n  return {\n    srcAmount,\n    destAmount: destAmountAfterSlippage,\n  };\n}\n\n/**\n * Calculates the destination amount after applying partner fee.\n *\n * @param price - The DeltaOrMarketPrice object containing destAmounts and partnerFee.\n * @param priceMode - The mode of the price, either \"delta\" or \"market\".\n * @returns The destination amount after applying partner fee.\n */\nexport function getDestAmountAfterFee(price: DeltaOrMarketPrice) {\n  if (isDeltaPrice(price)) {\n    // For Delta: (price.destAmount | price.bridgeInfo.destAmountAfterBridge) = price.receivedDestAmount are amounts after fee\n    return price.receivedDestAmount;\n  }\n\n  // For Market: price.destAmount is amount before fee\n  return subtractFee(price.destAmount, price.partnerFee);\n}\n\n/**\n * Calculates the destination amount after applying partner fee and slippage.\n *\n * @param price - The DeltaOrMarketPrice object containing destAmounts and partnerFee.\n * @param slippagePercent - The slippage percentage to apply.\n * @param priceMode - The mode of the price, either \"delta\" or \"market\".\n * @returns The destination amount after applying partner fee and slippage.\n */\nexport function getDestAmountAfterFeeAndSlippage({\n  price,\n  slippagePercent,\n}: {\n  price: DeltaOrMarketPrice;\n  slippagePercent: number;\n}) {\n  const destAmountAfterFee = getDestAmountAfterFee(price);\n  return subtractSlippage(destAmountAfterFee, slippagePercent);\n}\n\nexport function getPercentDifference(a: number, b: number) {\n  if (b === 0 || a === b) return 0;\n  return Big(a).minus(b).div(b).mul(100).toNumber();\n}\n"],"names":["applySlippage","srcAmount","destAmount","slippage","side","srcAmountAfterSlippage","amountAfterSlippage","toFixed","destAmountAfterSlippage","getDestAmountAfterFee","price","isDeltaPrice","receivedDestAmount","subtractFee","partnerFee","getDestAmountAfterFeeAndSlippage","slippagePercent","destAmountAfterFee","subtractSlippage","getPercentDifference","a","b","Big","minus","div","mul","toNumber"],"mappings":";;;;;AAeO,SAASA,aAAAA,CACd;AAAA,EACEC,SAAAA;AAAAA,EACAC;AACoD,CAAA,EACtDC,UACAC,IAAAA,EACA;AACA,EAAA,IAAIA,SAAS,KAAA,EAAO;AAClB,IAAA,MAAMC,yBAAyBC,mBAAAA,CAC7BL,SAAAA,EACAE,UACAC,IACF,CAAA,CAAEG,QAAQ,CAAC,CAAA;AAEX,IAAA,OAAO;AAAA,MACLN,SAAAA,EAAWI,sBAAAA;AAAAA,MACXH;AAAAA,KACF;AAAA,EACF;AAEA,EAAA,MAAMM,0BAA0BF,mBAAAA,CAC9BJ,UAAAA,EACAC,UACAC,IACF,CAAA,CAAEG,QAAQ,CAAC,CAAA;AAEX,EAAA,OAAO;AAAA,IACLN,SAAAA;AAAAA,IACAC,UAAAA,EAAYM;AAAAA,GACd;AACF;AASO,SAASC,sBAAsBC,KAAAA,EAA2B;AAC/D,EAAA,IAAIC,YAAAA,CAAaD,KAAK,CAAA,EAAG;AAEvB,IAAA,OAAOA,KAAAA,CAAME,kBAAAA;AAAAA,EACf;AAGA,EAAA,OAAOC,WAAAA,CAAYH,KAAAA,CAAMR,UAAAA,EAAYQ,KAAAA,CAAMI,UAAU,CAAA;AACvD;AAUO,SAASC,gCAAAA,CAAiC;AAAA,EAC/CL,KAAAA;AAAAA,EACAM;AAIF,CAAA,EAAG;AACD,EAAA,MAAMC,kBAAAA,GAAqBR,sBAAsBC,KAAK,CAAA;AACtD,EAAA,OAAOQ,gBAAAA,CAAiBD,oBAAoBD,eAAe,CAAA;AAC7D;AAEO,SAASG,oBAAAA,CAAqBC,GAAWC,CAAAA,EAAW;AACzD,EAAA,IAAIA,CAAAA,KAAM,CAAA,IAAKD,CAAAA,KAAMC,CAAAA,EAAG,OAAO,CAAA;AAC/B,EAAA,OAAOC,GAAAA,CAAIF,CAAC,CAAA,CAAEG,KAAAA,CAAMF,CAAC,CAAA,CAAEG,GAAAA,CAAIH,CAAC,CAAA,CAAEI,GAAAA,CAAI,GAAG,CAAA,CAAEC,QAAAA,EAAS;AAClD;;;;"}
+{"version":3,"file":"price.js","sources":["../../../src/lib/utils/price.ts"],"sourcesContent":["import type { DeltaOrMarketPrice } from \"@/hooks/swap/prices/types\";\nimport { amountAfterSlippage, subtractSlippage } from \"./slippage\";\nimport { subtractFee } from \"./fee\";\nimport Big from \"big.js\";\nimport { isDeltaPrice } from \"@/hooks/swap/prices/delta/queries/useDeltaPriceQuery\";\n\n/**\n * Applies slippage to the srcAmount and destAmount of a DeltaOrMarketPrice.\n *\n * @param srcAmount - The source amount of the trade.\n * @param destAmount - The destination amount of the trade.\n * @param slippage - The slippage percentage to apply (e.g., 0.5 for 0.5%).\n * @param side - The side of the trade, either \"BUY\" or \"SELL\".\n * @returns An object containing the adjusted srcAmount and destAmount after applying slippage.\n */\nexport function applySlippage(\n  {\n    srcAmount,\n    destAmount,\n  }: Pick<DeltaOrMarketPrice, \"srcAmount\" | \"destAmount\">,\n  slippage: number,\n  side: \"BUY\" | \"SELL\"\n) {\n  if (side === \"BUY\") {\n    const srcAmountAfterSlippage = amountAfterSlippage(\n      srcAmount,\n      slippage,\n      side\n    ).toFixed(0);\n\n    return {\n      srcAmount: srcAmountAfterSlippage,\n      destAmount,\n    };\n  }\n\n  const destAmountAfterSlippage = amountAfterSlippage(\n    destAmount,\n    slippage,\n    side\n  ).toFixed(0);\n\n  return {\n    srcAmount,\n    destAmount: destAmountAfterSlippage,\n  };\n}\n\n/**\n * Calculates the destination amount after applying partner fee.\n *\n * @param price - The DeltaOrMarketPrice object containing destAmounts and partnerFee.\n * @returns The destination amount after applying partner fee.\n */\nexport function getDestAmountAfterFee(price: DeltaOrMarketPrice) {\n  // destAmount has swapFees (and bridgeFees for Crosschain Delta) applied,\n  // but not partnerFee\n  const destAmount = isDeltaPrice(price)\n    ? price.receivedDestAmount\n    : price.destAmount;\n\n  return subtractFee(destAmount, price.partnerFee);\n}\n\n/**\n * Calculates the destination amount after applying partner fee and slippage.\n *\n * @param price - The DeltaOrMarketPrice object containing destAmounts and partnerFee.\n * @param slippagePercent - The slippage percentage to apply.\n * @param priceMode - The mode of the price, either \"delta\" or \"market\".\n * @returns The destination amount after applying partner fee and slippage.\n */\nexport function getDestAmountAfterFeeAndSlippage({\n  price,\n  slippagePercent,\n}: {\n  price: DeltaOrMarketPrice;\n  slippagePercent: number;\n}) {\n  const destAmountAfterFee = getDestAmountAfterFee(price);\n  return subtractSlippage(destAmountAfterFee, slippagePercent);\n}\n\nexport function getPercentDifference(a: number, b: number) {\n  if (b === 0 || a === b) return 0;\n  return Big(a).minus(b).div(b).mul(100).toNumber();\n}\n"],"names":["applySlippage","srcAmount","destAmount","slippage","side","srcAmountAfterSlippage","amountAfterSlippage","toFixed","destAmountAfterSlippage","getDestAmountAfterFee","price","isDeltaPrice","receivedDestAmount","subtractFee","partnerFee","getDestAmountAfterFeeAndSlippage","slippagePercent","destAmountAfterFee","subtractSlippage","getPercentDifference","a","b","Big","minus","div","mul","toNumber"],"mappings":";;;;;AAeO,SAASA,aAAAA,CACd;AAAA,EACEC,SAAAA;AAAAA,EACAC;AACoD,CAAA,EACtDC,UACAC,IAAAA,EACA;AACA,EAAA,IAAIA,SAAS,KAAA,EAAO;AAClB,IAAA,MAAMC,yBAAyBC,mBAAAA,CAC7BL,SAAAA,EACAE,UACAC,IACF,CAAA,CAAEG,QAAQ,CAAC,CAAA;AAEX,IAAA,OAAO;AAAA,MACLN,SAAAA,EAAWI,sBAAAA;AAAAA,MACXH;AAAAA,KACF;AAAA,EACF;AAEA,EAAA,MAAMM,0BAA0BF,mBAAAA,CAC9BJ,UAAAA,EACAC,UACAC,IACF,CAAA,CAAEG,QAAQ,CAAC,CAAA;AAEX,EAAA,OAAO;AAAA,IACLN,SAAAA;AAAAA,IACAC,UAAAA,EAAYM;AAAAA,GACd;AACF;AAQO,SAASC,sBAAsBC,KAAAA,EAA2B;AAG/D,EAAA,MAAMR,aAAaS,YAAAA,CAAaD,KAAK,CAAA,GACjCA,KAAAA,CAAME,qBACNF,KAAAA,CAAMR,UAAAA;AAEV,EAAA,OAAOW,WAAAA,CAAYX,UAAAA,EAAYQ,KAAAA,CAAMI,UAAU,CAAA;AACjD;AAUO,SAASC,gCAAAA,CAAiC;AAAA,EAC/CL,KAAAA;AAAAA,EACAM;AAIF,CAAA,EAAG;AACD,EAAA,MAAMC,kBAAAA,GAAqBR,sBAAsBC,KAAK,CAAA;AACtD,EAAA,OAAOQ,gBAAAA,CAAiBD,oBAAoBD,eAAe,CAAA;AAC7D;AAEO,SAASG,oBAAAA,CAAqBC,GAAWC,CAAAA,EAAW;AACzD,EAAA,IAAIA,CAAAA,KAAM,CAAA,IAAKD,CAAAA,KAAMC,CAAAA,EAAG,OAAO,CAAA;AAC/B,EAAA,OAAOC,GAAAA,CAAIF,CAAC,CAAA,CAAEG,KAAAA,CAAMF,CAAC,CAAA,CAAEG,GAAAA,CAAIH,CAAC,CAAA,CAAEI,GAAAA,CAAI,GAAG,CAAA,CAAEC,QAAAA,EAAS;AAClD;;;;"}

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

@@ -1,11 +1,10 @@
 import { Hash, TransactionReceipt } from 'viem';
 import { CallsReceipt } from '../../hooks/batch/useAwaitCalls';
 import { SupportedChainId } from '../web3/wagmi/types';
-import { NullableDeltaAuction } from '../../hooks/swap/prices/delta/orders/types';
 import { DeltaAuction } from '@velora-dex/sdk';
 export type OrderSentObject = {
     order: DeltaAuction;
-    lastOrderState: Promise<NullableDeltaAuction>;
+    lastOrderState: Promise<DeltaAuction>;
 };
 export declare function addTxToast({ transactionHash: _transactionHash, receiptPromise, chainId, }: {
     chainId: SupportedChainId;

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

@@ -1 +1 @@
-{"version":3,"file":"toasts.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/toasts.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAK1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAC/C,CAAC;AAEF,wBAAgB,UAAU,CAAC,EACzB,eAAe,EAAE,gBAAgB,EACjC,cAAc,EACd,OAAO,GACR,EAAE;IACD,OAAO,EAAE,gBAAgB,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC,kBAAkB,GAAG,YAAY,GAAG,SAAS,CAAC,CAAC;IACvE,eAAe,CAAC,EAAE,IAAI,CAAC;CACxB,QAmDA;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,eAAe,QA4B5D"}
+{"version":3,"file":"toasts.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/toasts.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAK1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,YAAY,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC;CACvC,CAAC;AAEF,wBAAgB,UAAU,CAAC,EACzB,eAAe,EAAE,gBAAgB,EACjC,cAAc,EACd,OAAO,GACR,EAAE;IACD,OAAO,EAAE,gBAAgB,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC,kBAAkB,GAAG,YAAY,GAAG,SAAS,CAAC,CAAC;IACvE,eAAe,CAAC,EAAE,IAAI,CAAC;CACxB,QAmDA;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,eAAe,QA4B5D"}

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

@@ -1 +1 @@
-{"version":3,"file":"toasts.js","sources":["../../../src/lib/utils/toasts.tsx"],"sourcesContent":["import { CustomToast } from \"@/components/widget/Toasts/CustomToast\";\nimport { toast } from \"sonner\";\nimport { type Hash, type TransactionReceipt } from \"viem\";\nimport {\n  constructExplorerOrderDetailsLink,\n  constructTxLinkForChain,\n} from \"./explorer\";\nimport type { CallsReceipt } from \"@/hooks/batch/useAwaitCalls\";\nimport type { SupportedChainId } from \"../web3/wagmi/types\";\nimport { getStandaloneTxHash } from \"@/transactions/hash\";\nimport type { NullableDeltaAuction } from \"@/hooks/swap/prices/delta/orders/types\";\nimport type { DeltaAuction } from \"@velora-dex/sdk\";\n\ntype ToastPromiseData<T> = NonNullable<Parameters<typeof toast.promise<T>>[1]>;\n\nexport type OrderSentObject = {\n  order: DeltaAuction;\n  lastOrderState: Promise<NullableDeltaAuction>;\n};\n\nexport function addTxToast({\n  transactionHash: _transactionHash,\n  receiptPromise,\n  chainId,\n}: {\n  chainId: SupportedChainId;\n  receiptPromise: Promise<TransactionReceipt | CallsReceipt | undefined>;\n  transactionHash?: Hash;\n}) {\n  const toastId = crypto.randomUUID();\n\n  const transactionHash = getStandaloneTxHash({\n    transactionHash: _transactionHash,\n  });\n  const _detailsLink = transactionHash\n    ? constructTxLinkForChain({ chainId, txHash: transactionHash })\n    : undefined;\n\n  const toastOptions: ToastPromiseData<\n    TransactionReceipt | CallsReceipt | undefined\n  > = {\n    id: toastId,\n    loading: (\n      <CustomToast\n        variant=\"loading\"\n        label=\"Pending Transaction\"\n        toastId={toastId}\n        detailsLink={_detailsLink}\n      />\n    ),\n    success: (receipt) => {\n      let detailsLink = _detailsLink;\n      if (!detailsLink && receipt) {\n        detailsLink = constructTxLinkForChain({\n          chainId,\n          txHash: receipt.transactionHash,\n        });\n      }\n\n      return (\n        <CustomToast\n          variant=\"success\"\n          label=\"Transaction Confirmed\"\n          toastId={toastId}\n          detailsLink={detailsLink}\n        />\n      );\n    },\n    error: (\n      <CustomToast\n        variant=\"error\"\n        label=\"Transaction Failed\"\n        toastId={toastId}\n        detailsLink={_detailsLink}\n      />\n    ),\n  };\n\n  toast.promise(receiptPromise, toastOptions);\n}\n\nexport function addDeltaOrderToast(orderSent: OrderSentObject) {\n  const customToastProps = {\n    toastId: crypto.randomUUID(),\n    detailsLink: constructExplorerOrderDetailsLink(orderSent.order.id),\n  };\n\n  const toastOptions = {\n    id: customToastProps.toastId,\n    loading: (\n      <CustomToast\n        variant=\"loading\"\n        label=\"Pending Order\"\n        {...customToastProps}\n      />\n    ),\n    success: (\n      <CustomToast\n        variant=\"success\"\n        label=\"Order Confirmed\"\n        {...customToastProps}\n      />\n    ),\n    error: (\n      <CustomToast variant=\"error\" label=\"Order Failed\" {...customToastProps} />\n    ),\n  };\n\n  toast.promise(orderSent.lastOrderState, toastOptions);\n}\n"],"names":["addTxToast","transactionHash","_transactionHash","receiptPromise","chainId","toastId","crypto","randomUUID","getStandaloneTxHash","_detailsLink","constructTxLinkForChain","txHash","undefined","toastOptions","id","loading","success","receipt","detailsLink","error","toast","promise","addDeltaOrderToast","orderSent","customToastProps","constructExplorerOrderDetailsLink","order","lastOrderState"],"mappings":";;;;;;;AAoBO,SAASA,UAAAA,CAAW;AAAA,EACzBC,eAAAA,EAAiBC,gBAAAA;AAAAA,EACjBC,cAAAA;AAAAA,EACAC;AAKF,CAAA,EAAG;AACD,EAAA,MAAMC,OAAAA,GAAUC,OAAOC,UAAAA,EAAW;AAElC,EAAA,MAAMN,kBAAkBO,mBAAAA,CAAoB;AAAA,IAC1CP,eAAAA,EAAiBC;AAAAA,GAClB,CAAA;AACD,EAAA,MAAMO,YAAAA,GAAeR,kBACjBS,uBAAAA,CAAwB;AAAA,IAAEN,OAAAA;AAAAA,IAASO,MAAAA,EAAQV;AAAAA,GAAiB,CAAA,GAC5DW,MAAAA;AAEJ,EAAA,MAAMC,YAAAA,GAEF;AAAA,IACFC,EAAAA,EAAIT,OAAAA;AAAAA,IACJU,OAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,qBAAA,EACN,OAAA,EACA,WAAA,EAAaN,YAAAA,EAAa,CAAA;AAAA,IAG9BO,SAAUC,CAAAA,OAAAA,KAAY;AACpB,MAAA,IAAIC,WAAAA,GAAcT,YAAAA;AAClB,MAAA,IAAI,CAACS,eAAeD,OAAAA,EAAS;AAC3BC,QAAAA,WAAAA,GAAcR,uBAAAA,CAAwB;AAAA,UACpCN,OAAAA;AAAAA,UACAO,QAAQM,OAAAA,CAAQhB;AAAAA,SACjB,CAAA;AAAA,MACH;AAEA,MAAA,2BACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,uBAAA,EACN,SACA,WAAA,EAAyB,CAAA;AAAA,IAG/B,CAAA;AAAA,IACAkB,KAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,SACR,KAAA,EAAM,oBAAA,EACN,OAAA,EACA,WAAA,EAAaV,YAAAA,EAAa;AAAA,GAGhC;AAEAW,EAAAA,KAAAA,CAAMC,OAAAA,CAAQlB,gBAAgBU,YAAY,CAAA;AAC5C;AAEO,SAASS,mBAAmBC,SAAAA,EAA4B;AAC7D,EAAA,MAAMC,gBAAAA,GAAmB;AAAA,IACvBnB,OAAAA,EAASC,OAAOC,UAAAA,EAAW;AAAA,IAC3BW,WAAAA,EAAaO,iCAAAA,CAAkCF,SAAAA,CAAUG,KAAAA,CAAMZ,EAAE;AAAA,GACnE;AAEA,EAAA,MAAMD,YAAAA,GAAe;AAAA,IACnBC,IAAIU,gBAAAA,CAAiBnB,OAAAA;AAAAA,IACrBU,OAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,eAAA,EACN,GAAIS,gBAAAA,EAAiB,CAAA;AAAA,IAGzBR,OAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,iBAAA,EACN,GAAIQ,gBAAAA,EAAiB,CAAA;AAAA,IAGzBL,KAAAA,sBACG,WAAA,EAAA,EAAY,OAAA,EAAQ,SAAQ,KAAA,EAAM,cAAA,EAAe,GAAIK,gBAAAA,EAAiB;AAAA,GAE3E;AAEAJ,EAAAA,KAAAA,CAAMC,OAAAA,CAAQE,SAAAA,CAAUI,cAAAA,EAAgBd,YAAY,CAAA;AACtD;;;;"}
+{"version":3,"file":"toasts.js","sources":["../../../src/lib/utils/toasts.tsx"],"sourcesContent":["import { CustomToast } from \"@/components/widget/Toasts/CustomToast\";\nimport { toast } from \"sonner\";\nimport { type Hash, type TransactionReceipt } from \"viem\";\nimport {\n  constructExplorerOrderDetailsLink,\n  constructTxLinkForChain,\n} from \"./explorer\";\nimport type { CallsReceipt } from \"@/hooks/batch/useAwaitCalls\";\nimport type { SupportedChainId } from \"../web3/wagmi/types\";\nimport { getStandaloneTxHash } from \"@/transactions/hash\";\nimport type { DeltaAuction } from \"@velora-dex/sdk\";\n\ntype ToastPromiseData<T> = NonNullable<Parameters<typeof toast.promise<T>>[1]>;\n\nexport type OrderSentObject = {\n  order: DeltaAuction;\n  lastOrderState: Promise<DeltaAuction>;\n};\n\nexport function addTxToast({\n  transactionHash: _transactionHash,\n  receiptPromise,\n  chainId,\n}: {\n  chainId: SupportedChainId;\n  receiptPromise: Promise<TransactionReceipt | CallsReceipt | undefined>;\n  transactionHash?: Hash;\n}) {\n  const toastId = crypto.randomUUID();\n\n  const transactionHash = getStandaloneTxHash({\n    transactionHash: _transactionHash,\n  });\n  const _detailsLink = transactionHash\n    ? constructTxLinkForChain({ chainId, txHash: transactionHash })\n    : undefined;\n\n  const toastOptions: ToastPromiseData<\n    TransactionReceipt | CallsReceipt | undefined\n  > = {\n    id: toastId,\n    loading: (\n      <CustomToast\n        variant=\"loading\"\n        label=\"Pending Transaction\"\n        toastId={toastId}\n        detailsLink={_detailsLink}\n      />\n    ),\n    success: (receipt) => {\n      let detailsLink = _detailsLink;\n      if (!detailsLink && receipt) {\n        detailsLink = constructTxLinkForChain({\n          chainId,\n          txHash: receipt.transactionHash,\n        });\n      }\n\n      return (\n        <CustomToast\n          variant=\"success\"\n          label=\"Transaction Confirmed\"\n          toastId={toastId}\n          detailsLink={detailsLink}\n        />\n      );\n    },\n    error: (\n      <CustomToast\n        variant=\"error\"\n        label=\"Transaction Failed\"\n        toastId={toastId}\n        detailsLink={_detailsLink}\n      />\n    ),\n  };\n\n  toast.promise(receiptPromise, toastOptions);\n}\n\nexport function addDeltaOrderToast(orderSent: OrderSentObject) {\n  const customToastProps = {\n    toastId: crypto.randomUUID(),\n    detailsLink: constructExplorerOrderDetailsLink(orderSent.order.id),\n  };\n\n  const toastOptions = {\n    id: customToastProps.toastId,\n    loading: (\n      <CustomToast\n        variant=\"loading\"\n        label=\"Pending Order\"\n        {...customToastProps}\n      />\n    ),\n    success: (\n      <CustomToast\n        variant=\"success\"\n        label=\"Order Confirmed\"\n        {...customToastProps}\n      />\n    ),\n    error: (\n      <CustomToast variant=\"error\" label=\"Order Failed\" {...customToastProps} />\n    ),\n  };\n\n  toast.promise(orderSent.lastOrderState, toastOptions);\n}\n"],"names":["addTxToast","transactionHash","_transactionHash","receiptPromise","chainId","toastId","crypto","randomUUID","getStandaloneTxHash","_detailsLink","constructTxLinkForChain","txHash","undefined","toastOptions","id","loading","success","receipt","detailsLink","error","toast","promise","addDeltaOrderToast","orderSent","customToastProps","constructExplorerOrderDetailsLink","order","lastOrderState"],"mappings":";;;;;;;AAmBO,SAASA,UAAAA,CAAW;AAAA,EACzBC,eAAAA,EAAiBC,gBAAAA;AAAAA,EACjBC,cAAAA;AAAAA,EACAC;AAKF,CAAA,EAAG;AACD,EAAA,MAAMC,OAAAA,GAAUC,OAAOC,UAAAA,EAAW;AAElC,EAAA,MAAMN,kBAAkBO,mBAAAA,CAAoB;AAAA,IAC1CP,eAAAA,EAAiBC;AAAAA,GAClB,CAAA;AACD,EAAA,MAAMO,YAAAA,GAAeR,kBACjBS,uBAAAA,CAAwB;AAAA,IAAEN,OAAAA;AAAAA,IAASO,MAAAA,EAAQV;AAAAA,GAAiB,CAAA,GAC5DW,MAAAA;AAEJ,EAAA,MAAMC,YAAAA,GAEF;AAAA,IACFC,EAAAA,EAAIT,OAAAA;AAAAA,IACJU,OAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,qBAAA,EACN,OAAA,EACA,WAAA,EAAaN,YAAAA,EAAa,CAAA;AAAA,IAG9BO,SAAUC,CAAAA,OAAAA,KAAY;AACpB,MAAA,IAAIC,WAAAA,GAAcT,YAAAA;AAClB,MAAA,IAAI,CAACS,eAAeD,OAAAA,EAAS;AAC3BC,QAAAA,WAAAA,GAAcR,uBAAAA,CAAwB;AAAA,UACpCN,OAAAA;AAAAA,UACAO,QAAQM,OAAAA,CAAQhB;AAAAA,SACjB,CAAA;AAAA,MACH;AAEA,MAAA,2BACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,uBAAA,EACN,SACA,WAAA,EAAyB,CAAA;AAAA,IAG/B,CAAA;AAAA,IACAkB,KAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,SACR,KAAA,EAAM,oBAAA,EACN,OAAA,EACA,WAAA,EAAaV,YAAAA,EAAa;AAAA,GAGhC;AAEAW,EAAAA,KAAAA,CAAMC,OAAAA,CAAQlB,gBAAgBU,YAAY,CAAA;AAC5C;AAEO,SAASS,mBAAmBC,SAAAA,EAA4B;AAC7D,EAAA,MAAMC,gBAAAA,GAAmB;AAAA,IACvBnB,OAAAA,EAASC,OAAOC,UAAAA,EAAW;AAAA,IAC3BW,WAAAA,EAAaO,iCAAAA,CAAkCF,SAAAA,CAAUG,KAAAA,CAAMZ,EAAE;AAAA,GACnE;AAEA,EAAA,MAAMD,YAAAA,GAAe;AAAA,IACnBC,IAAIU,gBAAAA,CAAiBnB,OAAAA;AAAAA,IACrBU,OAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,eAAA,EACN,GAAIS,gBAAAA,EAAiB,CAAA;AAAA,IAGzBR,OAAAA,sBACG,WAAA,EAAA,EACC,OAAA,EAAQ,WACR,KAAA,EAAM,iBAAA,EACN,GAAIQ,gBAAAA,EAAiB,CAAA;AAAA,IAGzBL,KAAAA,sBACG,WAAA,EAAA,EAAY,OAAA,EAAQ,SAAQ,KAAA,EAAM,cAAA,EAAe,GAAIK,gBAAAA,EAAiB;AAAA,GAE3E;AAEAJ,EAAAA,KAAAA,CAAMC,OAAAA,CAAQE,SAAAA,CAAUI,cAAAA,EAAgBd,YAAY,CAAA;AACtD;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"twap.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/twap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAMpE,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,MAAM,CAGT;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,MAAM,CAGT;AAED,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,SAAS,GACV,EAAE;IACD,KAAK,EAAE,kBAAkB,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;;;EAQA;AAED,wBAAgB,oBAAoB,CAAC,EACnC,WAAW,EACX,SAAS,GACV,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;;;EAcA"}
+{"version":3,"file":"twap.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/twap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAMpE,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,MAAM,CAGT;AAED,wBAAgB,kBAAkB,CAAC,EACjC,QAAQ,EACR,SAAS,GACV,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,MAAM,CAGT;AAED,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,SAAS,GACV,EAAE;IACD,KAAK,EAAE,kBAAkB,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;CACnB;;;EAQA;AACD,wBAAgB,oBAAoB,CAAC,EACnC,WAAW,EACX,SAAS,GACV,EAAE;IACD,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;;;EAcA"}

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

@@ -1 +1 @@
-{"version":3,"file":"twap.js","sources":["../../../src/lib/utils/twap.ts"],"sourcesContent":["import type { DeltaOrBridgePrice } from \"@/hooks/swap/prices/types\";\nimport Big from \"big.js\";\nimport { millisecondsToSeconds, minutesToMilliseconds } from \"./time\";\nimport { TEN_MINUTES_MS } from \"../constants/time\";\nimport { produceDeltaOrderDeadline } from \"./delta\";\n\nexport function getTwapChunkAmount({\n  totalWei,\n  numSlices,\n}: {\n  totalWei: string;\n  numSlices: number;\n}): string {\n  if (numSlices <= 0 || totalWei === \"0\") return totalWei;\n  return Big(totalWei).div(numSlices).toFixed(0, 0); // roundDown to avoid overestimating\n}\n\nexport function getTotalTwapAmount({\n  chunkWei,\n  numSlices,\n}: {\n  chunkWei: string;\n  numSlices: number;\n}): string {\n  if (numSlices <= 0 || chunkWei === \"0\") return chunkWei;\n  return Big(chunkWei).mul(numSlices).toFixed();\n}\n\nexport function getTwapAmountsFromPrice({\n  price,\n  numSlices,\n}: {\n  price: DeltaOrBridgePrice;\n  numSlices: number;\n}) {\n  return {\n    srcAmount: getTotalTwapAmount({ chunkWei: price.srcAmount, numSlices }),\n    destAmount: getTotalTwapAmount({\n      chunkWei: price.receivedDestAmount,\n      numSlices,\n    }),\n  };\n}\n\nexport function produceTwapDeadlines({\n  durationMin,\n  numSlices,\n}: {\n  durationMin: number;\n  numSlices: number;\n}) {\n  const orderDurationMs = minutesToMilliseconds(durationMin);\n  const orderDeadline = produceDeltaOrderDeadline(\n    // 10 min buffer for possible delays in order creation or slice executions\n    orderDurationMs + TEN_MINUTES_MS\n  );\n  const orderInterval = Math.floor(\n    millisecondsToSeconds(orderDurationMs) / numSlices\n  );\n\n  return {\n    orderDeadline: Number(orderDeadline),\n    orderInterval,\n  };\n}\n"],"names":["getTwapChunkAmount","totalWei","numSlices","Big","div","toFixed","getTotalTwapAmount","chunkWei","mul","getTwapAmountsFromPrice","price","srcAmount","destAmount","receivedDestAmount","produceTwapDeadlines","durationMin","orderDurationMs","minutesToMilliseconds","orderDeadline","produceDeltaOrderDeadline","TEN_MINUTES_MS","orderInterval","Math","floor","millisecondsToSeconds","Number"],"mappings":";;;;;AAMO,SAASA,kBAAAA,CAAmB;AAAA,EACjCC,QAAAA;AAAAA,EACAC;AAIF,CAAA,EAAW;AACT,EAAA,IAAIA,SAAAA,IAAa,CAAA,IAAKD,QAAAA,KAAa,GAAA,EAAK,OAAOA,QAAAA;AAC/C,EAAA,OAAOE,GAAAA,CAAIF,QAAQ,CAAA,CAAEG,GAAAA,CAAIF,SAAS,CAAA,CAAEG,OAAAA,CAAQ,GAAG,CAAC,CAAA;AAClD;AAEO,SAASC,kBAAAA,CAAmB;AAAA,EACjCC,QAAAA;AAAAA,EACAL;AAIF,CAAA,EAAW;AACT,EAAA,IAAIA,SAAAA,IAAa,CAAA,IAAKK,QAAAA,KAAa,GAAA,EAAK,OAAOA,QAAAA;AAC/C,EAAA,OAAOJ,IAAII,QAAQ,CAAA,CAAEC,GAAAA,CAAIN,SAAS,EAAEG,OAAAA,EAAQ;AAC9C;AAEO,SAASI,uBAAAA,CAAwB;AAAA,EACtCC,KAAAA;AAAAA,EACAR;AAIF,CAAA,EAAG;AACD,EAAA,OAAO;AAAA,IACLS,WAAWL,kBAAAA,CAAmB;AAAA,MAAEC,UAAUG,KAAAA,CAAMC,SAAAA;AAAAA,MAAWT;AAAAA,KAAW,CAAA;AAAA,IACtEU,YAAYN,kBAAAA,CAAmB;AAAA,MAC7BC,UAAUG,KAAAA,CAAMG,kBAAAA;AAAAA,MAChBX;AAAAA,KACD;AAAA,GACH;AACF;AAEO,SAASY,oBAAAA,CAAqB;AAAA,EACnCC,WAAAA;AAAAA,EACAb;AAIF,CAAA,EAAG;AACD,EAAA,MAAMc,eAAAA,GAAkBC,sBAAsBF,WAAW,CAAA;AACzD,EAAA,MAAMG,aAAAA,GAAgBC,yBAAAA;AAAAA;AAAAA,IAEpBH,eAAAA,GAAkBI;AAAAA,GACpB;AACA,EAAA,MAAMC,gBAAgBC,IAAAA,CAAKC,KAAAA,CACzBC,qBAAAA,CAAsBR,eAAe,IAAId,SAC3C,CAAA;AAEA,EAAA,OAAO;AAAA,IACLgB,aAAAA,EAAeO,OAAOP,aAAa,CAAA;AAAA,IACnCG;AAAAA,GACF;AACF;;;;"}
+{"version":3,"file":"twap.js","sources":["../../../src/lib/utils/twap.ts"],"sourcesContent":["import type { DeltaOrBridgePrice } from \"@/hooks/swap/prices/types\";\nimport Big from \"big.js\";\nimport { millisecondsToSeconds, minutesToMilliseconds } from \"./time\";\nimport { TEN_MINUTES_MS } from \"../constants/time\";\nimport { produceDeltaOrderDeadline } from \"./delta\";\n\nexport function getTwapChunkAmount({\n  totalWei,\n  numSlices,\n}: {\n  totalWei: string;\n  numSlices: number;\n}): string {\n  if (numSlices <= 0 || totalWei === \"0\") return totalWei;\n  return Big(totalWei).div(numSlices).toFixed(0, 0); // roundDown to avoid overestimating\n}\n\nexport function getTotalTwapAmount({\n  chunkWei,\n  numSlices,\n}: {\n  chunkWei: string;\n  numSlices: number;\n}): string {\n  if (numSlices <= 0 || chunkWei === \"0\") return chunkWei;\n  return Big(chunkWei).mul(numSlices).toFixed();\n}\n\nexport function getTwapAmountsFromPrice({\n  price,\n  numSlices,\n}: {\n  price: DeltaOrBridgePrice;\n  numSlices: number;\n}) {\n  return {\n    srcAmount: getTotalTwapAmount({ chunkWei: price.srcAmount, numSlices }),\n    destAmount: getTotalTwapAmount({\n      chunkWei: price.receivedDestAmount,\n      numSlices,\n    }),\n  };\n}\nexport function produceTwapDeadlines({\n  durationMin,\n  numSlices,\n}: {\n  durationMin: number;\n  numSlices: number;\n}) {\n  const orderDurationMs = minutesToMilliseconds(durationMin);\n  const orderDeadline = produceDeltaOrderDeadline(\n    // 10 min buffer for possible delays in order creation or slice executions\n    orderDurationMs + TEN_MINUTES_MS\n  );\n  const orderInterval = Math.floor(\n    millisecondsToSeconds(orderDurationMs) / numSlices\n  );\n\n  return {\n    orderDeadline: Number(orderDeadline),\n    orderInterval,\n  };\n}\n"],"names":["getTwapChunkAmount","totalWei","numSlices","Big","div","toFixed","getTotalTwapAmount","chunkWei","mul","getTwapAmountsFromPrice","price","srcAmount","destAmount","receivedDestAmount","produceTwapDeadlines","durationMin","orderDurationMs","minutesToMilliseconds","orderDeadline","produceDeltaOrderDeadline","TEN_MINUTES_MS","orderInterval","Math","floor","millisecondsToSeconds","Number"],"mappings":";;;;;AAMO,SAASA,kBAAAA,CAAmB;AAAA,EACjCC,QAAAA;AAAAA,EACAC;AAIF,CAAA,EAAW;AACT,EAAA,IAAIA,SAAAA,IAAa,CAAA,IAAKD,QAAAA,KAAa,GAAA,EAAK,OAAOA,QAAAA;AAC/C,EAAA,OAAOE,GAAAA,CAAIF,QAAQ,CAAA,CAAEG,GAAAA,CAAIF,SAAS,CAAA,CAAEG,OAAAA,CAAQ,GAAG,CAAC,CAAA;AAClD;AAEO,SAASC,kBAAAA,CAAmB;AAAA,EACjCC,QAAAA;AAAAA,EACAL;AAIF,CAAA,EAAW;AACT,EAAA,IAAIA,SAAAA,IAAa,CAAA,IAAKK,QAAAA,KAAa,GAAA,EAAK,OAAOA,QAAAA;AAC/C,EAAA,OAAOJ,IAAII,QAAQ,CAAA,CAAEC,GAAAA,CAAIN,SAAS,EAAEG,OAAAA,EAAQ;AAC9C;AAEO,SAASI,uBAAAA,CAAwB;AAAA,EACtCC,KAAAA;AAAAA,EACAR;AAIF,CAAA,EAAG;AACD,EAAA,OAAO;AAAA,IACLS,WAAWL,kBAAAA,CAAmB;AAAA,MAAEC,UAAUG,KAAAA,CAAMC,SAAAA;AAAAA,MAAWT;AAAAA,KAAW,CAAA;AAAA,IACtEU,YAAYN,kBAAAA,CAAmB;AAAA,MAC7BC,UAAUG,KAAAA,CAAMG,kBAAAA;AAAAA,MAChBX;AAAAA,KACD;AAAA,GACH;AACF;AACO,SAASY,oBAAAA,CAAqB;AAAA,EACnCC,WAAAA;AAAAA,EACAb;AAIF,CAAA,EAAG;AACD,EAAA,MAAMc,eAAAA,GAAkBC,sBAAsBF,WAAW,CAAA;AACzD,EAAA,MAAMG,aAAAA,GAAgBC,yBAAAA;AAAAA;AAAAA,IAEpBH,eAAAA,GAAkBI;AAAAA,GACpB;AACA,EAAA,MAAMC,gBAAgBC,IAAAA,CAAKC,KAAAA,CACzBC,qBAAAA,CAAsBR,eAAe,IAAId,SAC3C,CAAA;AAEA,EAAA,OAAO;AAAA,IACLgB,aAAAA,EAAeO,OAAOP,aAAa,CAAA;AAAA,IACnCG;AAAAA,GACF;AACF;;;;"}

package/dist/styles.css

@@ -818,6 +818,9 @@
 .velora-widget.velora-widget .min-h-\[620px\] {
   min-height: 620px;
 }
+.velora-widget.velora-widget .w-0\.5 {
+  width: calc(var(--spacing) * .5);
+}
 .velora-widget.velora-widget .w-3\.5 {
   width: calc(var(--spacing) * 3.5);
 }
@@ -833,9 +836,6 @@
 .velora-widget.velora-widget .w-\[1px\] {
   width: 1px;
 }
-.velora-widget.velora-widget .w-\[2px\] {
-  width: 2px;
-}
 .velora-widget.velora-widget .w-\[18px\] {
   width: 18px;
 }
@@ -1043,6 +1043,9 @@
 .velora-widget.velora-widget .grid-cols-4 {
   grid-template-columns: repeat(4, minmax(0, 1fr));
 }
+.velora-widget.velora-widget .grid-cols-\[1fr_auto_1fr_auto_1fr\] {
+  grid-template-columns: 1fr auto 1fr auto 1fr;
+}
 .velora-widget.velora-widget .grid-cols-\[auto_1fr\] {
   grid-template-columns: auto 1fr;
 }
@@ -1127,9 +1130,15 @@
 .velora-widget.velora-widget .gap-6 {
   gap: calc(var(--spacing) * 6);
 }
+.velora-widget.velora-widget .gap-7 {
+  gap: calc(var(--spacing) * 7);
+}
 .velora-widget.velora-widget .gap-10 {
   gap: calc(var(--spacing) * 10);
 }
+.velora-widget.velora-widget .gap-14 {
+  gap: calc(var(--spacing) * 14);
+}
 .velora-widget.velora-widget .gap-\[1px\] {
   gap: 1px;
 }

package/dist/tokens/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tokens/constants.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAE/D,eAAO,MAAM,WAAW,+CAA+C,CAAC;AAExE,eAAO,MAAM,qBAAqB,EAAgC,SAAS,CACzE,OAAO,WAAW,CACnB,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAWjE,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,OAAO,CAC1C,MAAM,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAMlC,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/tokens/constants.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAEpC,eAAO,MAAM,2BAA2B,sBAAsB,CAAC;AAE/D,eAAO,MAAM,WAAW,+CAA+C,CAAC;AAExE,eAAO,MAAM,qBAAqB,EAAgC,SAAS,CACzE,OAAO,WAAW,CACnB,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,gBAAgB,EAAE,MAAM,CAUjE,CAAC;AAEF,eAAO,MAAM,sBAAsB,EAAE,OAAO,CAC1C,MAAM,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAMlC,CAAC"}

package/dist/tokens/constants.js

@@ -4,15 +4,15 @@ const QUERY_KEY_FETCH_TOKEN_LISTS = "fetch-token-lists";
 const ETH_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 const ETH_ADDRESS_LOWERCASE = ETH_ADDRESS.toLowerCase();
 const NATIVE_CURRENCY_ICON = {
-  [mainnet.id]: "https://cdn.paraswap.io/token/ETH.svg",
-  [bsc.id]: "https://cdn.paraswap.io/token/BNB.svg",
-  [optimism.id]: "https://cdn.paraswap.io/token/ETH.svg",
-  [avalanche.id]: "https://cdn.paraswap.io/token/AVAX.svg",
-  [arbitrum.id]: "https://cdn.paraswap.io/token/ETH.svg",
-  [polygon.id]: "https://cdn.paraswap.io/token/MATIC.svg",
-  [base.id]: "https://cdn.paraswap.io/token/ETH.svg",
-  [gnosis.id]: "https://assets.coingecko.com/coins/images/11062/thumb/Identity-Primary-DarkBG.png?1696511004",
-  [unichain.id]: "https://cdn.paraswap.io/token/ETH.svg"
+  [mainnet.id]: "https://cdn.velora.xyz/token/ETH.svg",
+  [bsc.id]: "https://cdn.velora.xyz/token/BNB.svg",
+  [optimism.id]: "https://cdn.velora.xyz/token/ETH.svg",
+  [avalanche.id]: "https://cdn.velora.xyz/token/AVAX.svg",
+  [arbitrum.id]: "https://cdn.velora.xyz/token/ETH.svg",
+  [polygon.id]: "https://cdn.velora.xyz/token/MATIC.svg",
+  [base.id]: "https://cdn.velora.xyz/token/ETH.svg",
+  [gnosis.id]: "https://cdn.velora.xyz/token/xDAI.svg",
+  [unichain.id]: "https://cdn.velora.xyz/token/ETH.svg"
 };
 const VLR_ADDRESS_BY_NETWORK = {
   [mainnet.id]: "0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74",

package/dist/tokens/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sources":["../../src/tokens/constants.ts"],"sourcesContent":["import {\n  mainnet,\n  bsc,\n  optimism,\n  avalanche,\n  arbitrum,\n  polygon,\n  base,\n  gnosis,\n  unichain,\n} from \"@/lib/web3/wagmi/supportedChains\";\nimport type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport type { Address } from \"viem\";\n\nexport const QUERY_KEY_FETCH_TOKEN_LISTS = \"fetch-token-lists\";\n\nexport const ETH_ADDRESS = \"0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE\";\n\nexport const ETH_ADDRESS_LOWERCASE = ETH_ADDRESS.toLowerCase() as Lowercase<\n  typeof ETH_ADDRESS\n>;\n\nexport const NATIVE_CURRENCY_ICON: Record<SupportedChainId, string> = {\n  [mainnet.id]: \"https://cdn.paraswap.io/token/ETH.svg\",\n  [bsc.id]: \"https://cdn.paraswap.io/token/BNB.svg\",\n  [optimism.id]: \"https://cdn.paraswap.io/token/ETH.svg\",\n  [avalanche.id]: \"https://cdn.paraswap.io/token/AVAX.svg\",\n  [arbitrum.id]: \"https://cdn.paraswap.io/token/ETH.svg\",\n  [polygon.id]: \"https://cdn.paraswap.io/token/MATIC.svg\",\n  [base.id]: \"https://cdn.paraswap.io/token/ETH.svg\",\n  [gnosis.id]:\n    \"https://assets.coingecko.com/coins/images/11062/thumb/Identity-Primary-DarkBG.png?1696511004\",\n  [unichain.id]: \"https://cdn.paraswap.io/token/ETH.svg\",\n};\n\nexport const VLR_ADDRESS_BY_NETWORK: Partial<\n  Record<SupportedChainId, Address>\n> = {\n  [mainnet.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n  [optimism.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n  [bsc.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n  [base.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n};\n"],"names":["QUERY_KEY_FETCH_TOKEN_LISTS","ETH_ADDRESS","ETH_ADDRESS_LOWERCASE","toLowerCase","NATIVE_CURRENCY_ICON","mainnet","id","bsc","optimism","avalanche","arbitrum","polygon","base","gnosis","unichain","VLR_ADDRESS_BY_NETWORK"],"mappings":";;AAcO,MAAMA,2BAAAA,GAA8B;AAEpC,MAAMC,WAAAA,GAAc;AAEpB,MAAMC,qBAAAA,GAAwBD,YAAYE,WAAAA;AAI1C,MAAMC,oBAAAA,GAAyD;AAAA,EACpE,CAACC,OAAAA,CAAQC,EAAE,GAAG,uCAAA;AAAA,EACd,CAACC,GAAAA,CAAID,EAAE,GAAG,uCAAA;AAAA,EACV,CAACE,QAAAA,CAASF,EAAE,GAAG,uCAAA;AAAA,EACf,CAACG,SAAAA,CAAUH,EAAE,GAAG,wCAAA;AAAA,EAChB,CAACI,QAAAA,CAASJ,EAAE,GAAG,uCAAA;AAAA,EACf,CAACK,OAAAA,CAAQL,EAAE,GAAG,yCAAA;AAAA,EACd,CAACM,IAAAA,CAAKN,EAAE,GAAG,uCAAA;AAAA,EACX,CAACO,MAAAA,CAAOP,EAAE,GACR,8FAAA;AAAA,EACF,CAACQ,QAAAA,CAASR,EAAE,GAAG;AACjB;AAEO,MAAMS,sBAAAA,GAET;AAAA,EACF,CAACV,OAAAA,CAAQC,EAAE,GAAG,4CAAA;AAAA,EACd,CAACE,QAAAA,CAASF,EAAE,GAAG,4CAAA;AAAA,EACf,CAACC,GAAAA,CAAID,EAAE,GAAG,4CAAA;AAAA,EACV,CAACM,IAAAA,CAAKN,EAAE,GAAG;AACb;;;;"}
+{"version":3,"file":"constants.js","sources":["../../src/tokens/constants.ts"],"sourcesContent":["import {\n  mainnet,\n  bsc,\n  optimism,\n  avalanche,\n  arbitrum,\n  polygon,\n  base,\n  gnosis,\n  unichain,\n} from \"@/lib/web3/wagmi/supportedChains\";\nimport type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport type { Address } from \"viem\";\n\nexport const QUERY_KEY_FETCH_TOKEN_LISTS = \"fetch-token-lists\";\n\nexport const ETH_ADDRESS = \"0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE\";\n\nexport const ETH_ADDRESS_LOWERCASE = ETH_ADDRESS.toLowerCase() as Lowercase<\n  typeof ETH_ADDRESS\n>;\n\nexport const NATIVE_CURRENCY_ICON: Record<SupportedChainId, string> = {\n  [mainnet.id]: \"https://cdn.velora.xyz/token/ETH.svg\",\n  [bsc.id]: \"https://cdn.velora.xyz/token/BNB.svg\",\n  [optimism.id]: \"https://cdn.velora.xyz/token/ETH.svg\",\n  [avalanche.id]: \"https://cdn.velora.xyz/token/AVAX.svg\",\n  [arbitrum.id]: \"https://cdn.velora.xyz/token/ETH.svg\",\n  [polygon.id]: \"https://cdn.velora.xyz/token/MATIC.svg\",\n  [base.id]: \"https://cdn.velora.xyz/token/ETH.svg\",\n  [gnosis.id]: \"https://cdn.velora.xyz/token/xDAI.svg\",\n  [unichain.id]: \"https://cdn.velora.xyz/token/ETH.svg\",\n};\n\nexport const VLR_ADDRESS_BY_NETWORK: Partial<\n  Record<SupportedChainId, Address>\n> = {\n  [mainnet.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n  [optimism.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n  [bsc.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n  [base.id]: \"0x4e107a0000DB66f0E9Fd2039288Bf811dD1f9c74\",\n};\n"],"names":["QUERY_KEY_FETCH_TOKEN_LISTS","ETH_ADDRESS","ETH_ADDRESS_LOWERCASE","toLowerCase","NATIVE_CURRENCY_ICON","mainnet","id","bsc","optimism","avalanche","arbitrum","polygon","base","gnosis","unichain","VLR_ADDRESS_BY_NETWORK"],"mappings":";;AAcO,MAAMA,2BAAAA,GAA8B;AAEpC,MAAMC,WAAAA,GAAc;AAEpB,MAAMC,qBAAAA,GAAwBD,YAAYE,WAAAA;AAI1C,MAAMC,oBAAAA,GAAyD;AAAA,EACpE,CAACC,OAAAA,CAAQC,EAAE,GAAG,sCAAA;AAAA,EACd,CAACC,GAAAA,CAAID,EAAE,GAAG,sCAAA;AAAA,EACV,CAACE,QAAAA,CAASF,EAAE,GAAG,sCAAA;AAAA,EACf,CAACG,SAAAA,CAAUH,EAAE,GAAG,uCAAA;AAAA,EAChB,CAACI,QAAAA,CAASJ,EAAE,GAAG,sCAAA;AAAA,EACf,CAACK,OAAAA,CAAQL,EAAE,GAAG,wCAAA;AAAA,EACd,CAACM,IAAAA,CAAKN,EAAE,GAAG,sCAAA;AAAA,EACX,CAACO,MAAAA,CAAOP,EAAE,GAAG,uCAAA;AAAA,EACb,CAACQ,QAAAA,CAASR,EAAE,GAAG;AACjB;AAEO,MAAMS,sBAAAA,GAET;AAAA,EACF,CAACV,OAAAA,CAAQC,EAAE,GAAG,4CAAA;AAAA,EACd,CAACE,QAAAA,CAASF,EAAE,GAAG,4CAAA;AAAA,EACf,CAACC,GAAAA,CAAID,EAAE,GAAG,4CAAA;AAAA,EACV,CAACM,IAAAA,CAAKN,EAAE,GAAG;AACb;;;;"}