@velora-dex/widget 0.4.14 → 0.5.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTxResponse.d.ts","sourceRoot":"","sources":["../../../../src/hooks/txs/queries/useTxResponse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,yCAAyC,CAAC;AAEjD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,wBAAgB,mBAAmB,IAAI,kBAAkB,CAKxD;AAED,KAAK,kBAAkB,GAAG;IACxB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,wBAAgB,aAAa,CAAC,EAC5B,IAAI,EACJ,OAAO,EACP,OAAc,GACf,EAAE,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAc6tE,CAAC;;;;;;;;;;;;+BAAgrB,CAAC;mCAAgG,CAAC;;;;;;;;;;;;;;;;;;;;;;4BAAw5B,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA+B,CAAC;;;;;;;;;;;;;;;;;;8BAA8xB,CAAC;qCAA0D,CAAC;uCAA4D,CAAC;2BAAgD,CAAC;2BAA6C,CAAC;;;oCAA2H,CAAC;gCAAqD,CAAC;wCAA6D,CAAC;8BAAmD,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;uCAA4D,CAAC;;;;oCAA6J,CAAC;gCAAqD,CAAC;wCAA6D,CAAC;8BAAmD,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;uCAA4D,CAAC;;;4BAAmH,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;;;;4BAAiM,CAAC;;;;8BAAiL,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;;uCAA03B,CAAC;;;4BAAmH,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;gCAAsR,CAAC;+BAAiD,CAAC;;;;;;;;;;wBAAsgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAApjS,CAAC;;;;;;;;;;;;+BAAgrB,CAAC;mCAAgG,CAAC;;;;;;;;;;;;;;;;;;;;;;4BAAw5B,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA+B,CAAC;;;;;;;;;;;;;;;;;;8BAA8xB,CAAC;qCAA0D,CAAC;uCAA4D,CAAC;2BAAgD,CAAC;2BAA6C,CAAC;;;oCAA2H,CAAC;gCAAqD,CAAC;wCAA6D,CAAC;8BAAmD,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;uCAA4D,CAAC;;;;oCAA6J,CAAC;gCAAqD,CAAC;wCAA6D,CAAC;8BAAmD,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;uCAA4D,CAAC;;;4BAAmH,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;;;;4BAAiM,CAAC;;;;8BAAiL,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;;uCAA03B,CAAC;;;4BAAmH,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;gCAAsR,CAAC;+BAAiD,CAAC;;;;;;;;;;wBAAsgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAA52S,CAAC;;;;;;;;;;;;+BAAgrB,CAAC;mCAAgG,CAAC;;;;;;;;;;;;;;;;;;;;;;4BAAw5B,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA+B,CAAC;;;;;;;;;;;;;;;;;;8BAA8xB,CAAC;qCAA0D,CAAC;uCAA4D,CAAC;2BAAgD,CAAC;2BAA6C,CAAC;;;oCAA2H,CAAC;gCAAqD,CAAC;wCAA6D,CAAC;8BAAmD,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;uCAA4D,CAAC;;;;oCAA6J,CAAC;gCAAqD,CAAC;wCAA6D,CAAC;8BAAmD,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;uCAA4D,CAAC;;;4BAAmH,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;qCAAmyB,CAAC;;;;4BAAiM,CAAC;;;;8BAAiL,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;;;;;;;;;;;;;uCAA03B,CAAC;;;4BAAmH,CAAC;oCAAyD,CAAC;;;8BAAuI,CAAC;wBAA6C,CAAC;8BAAmD,CAAC;;;;;;;gCAAsR,CAAC;+BAAiD,CAAC;;;;;;;;;;wBAAsgB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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, OTCOrderFormState, SwapFormState, SettingsState, TokenFormState, WidgetState, AccountState, } from './events/types/common';
-export type { WidgetEventCallbacks, OnConnectWallet, OnAllowToken, OnWrapETH, OnSwap, OnLimitOrder, OnOTCOrder, OnSettingsChange, OnCancelOrder, OnFillOTCOrder, OnFormInputChange, OnPriceChange, } from './events/types';
+export type { WidgetEventCallbacks, OnConnectWallet, OnAllowToken, OnWrapETH, OnSwap, 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,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,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,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,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/styles.css

@@ -1112,6 +1112,9 @@
 .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);
 }

package/dist/transactions/queries/ensureEstimateFeesPerGas.d.ts

@@ -0,0 +1,16 @@
+import { wagmiConfig as _wagmiConfig } from '../../lib/web3/wagmi/config';
+import { QueryClient } from '@tanstack/react-query';
+import { FeeValuesType } from 'viem';
+import { SupportedChainId } from '../../lib/web3/wagmi/types';
+import { EstimateFeesPerGasReturnType } from '@wagmi/core';
+export type EstimateFeesPerGasFn = (options: {
+    chainId: SupportedChainId;
+    type?: FeeValuesType;
+}) => Promise<EstimateFeesPerGasReturnType>;
+type EstimateFeesPerGasFactory = (params?: {
+    queryClient?: QueryClient;
+    wagmiConfig?: typeof _wagmiConfig;
+}) => EstimateFeesPerGasFn;
+export declare const estimateFeesPerGasFactory: EstimateFeesPerGasFactory;
+export {};
+//# sourceMappingURL=ensureEstimateFeesPerGas.d.ts.map

package/dist/transactions/queries/ensureEstimateFeesPerGas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureEstimateFeesPerGas.d.ts","sourceRoot":"","sources":["../../../src/transactions/queries/ensureEstimateFeesPerGas.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,MAAM,CAAC;AAG1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAC;AAEhE,MAAM,MAAM,oBAAoB,GAAG,CAAC,OAAO,EAAE;IAC3C,OAAO,EAAE,gBAAgB,CAAC;IAC1B,IAAI,CAAC,EAAE,aAAa,CAAC;CACtB,KAAK,OAAO,CAAC,4BAA4B,CAAC,CAAC;AAE5C,KAAK,yBAAyB,GAAG,CAAC,MAAM,CAAC,EAAE;IACzC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,YAAY,CAAC;CACnC,KAAK,oBAAoB,CAAC;AAE3B,eAAO,MAAM,yBAAyB,EAAE,yBAarC,CAAC"}

package/dist/transactions/queries/ensureEstimateFeesPerGas.js

@@ -0,0 +1,23 @@
+import { queryClient } from '../../lib/queryClient.js';
+import { wagmiConfig } from '../../lib/web3/wagmi/config.js';
+import 'viem';
+import { estimateFeesPerGasQueryOptions } from 'wagmi/query';
+
+const estimateFeesPerGasFactory = (options = {}) => async ({
+  chainId,
+  type = "eip1559"
+}) => {
+  const {
+    queryClient: queryClient$1 = queryClient,
+    wagmiConfig: wagmiConfig$1 = wagmiConfig
+  } = options;
+  const queryOptions = estimateFeesPerGasQueryOptions(wagmiConfig$1, {
+    chainId,
+    type
+  });
+  const gasFeeResponse = await queryClient$1.ensureQueryData(queryOptions);
+  return gasFeeResponse;
+};
+
+export { estimateFeesPerGasFactory };
+//# sourceMappingURL=ensureEstimateFeesPerGas.js.map

package/dist/transactions/queries/ensureEstimateFeesPerGas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureEstimateFeesPerGas.js","sources":["../../../src/transactions/queries/ensureEstimateFeesPerGas.ts"],"sourcesContent":["import { queryClient as _queryClient } from \"@/lib/queryClient\";\nimport { wagmiConfig as _wagmiConfig } from \"@/lib/web3/wagmi/config\";\nimport type { QueryClient } from \"@tanstack/react-query\";\n\nimport { type FeeValuesType } from \"viem\";\n\nimport { estimateFeesPerGasQueryOptions } from \"wagmi/query\";\nimport type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport type { EstimateFeesPerGasReturnType } from \"@wagmi/core\";\n\nexport type EstimateFeesPerGasFn = (options: {\n  chainId: SupportedChainId;\n  type?: FeeValuesType;\n}) => Promise<EstimateFeesPerGasReturnType>;\n\ntype EstimateFeesPerGasFactory = (params?: {\n  queryClient?: QueryClient;\n  wagmiConfig?: typeof _wagmiConfig;\n}) => EstimateFeesPerGasFn;\n\nexport const estimateFeesPerGasFactory: EstimateFeesPerGasFactory =\n  (options = {}) =>\n  async ({ chainId, type = \"eip1559\" }) => {\n    const { queryClient = _queryClient, wagmiConfig = _wagmiConfig } = options;\n\n    const queryOptions = estimateFeesPerGasQueryOptions(wagmiConfig, {\n      chainId,\n      type,\n    });\n\n    const gasFeeResponse = await queryClient.ensureQueryData(queryOptions);\n\n    return gasFeeResponse;\n  };\n"],"names":["estimateFeesPerGasFactory","options","chainId","type","queryClient","_queryClient","wagmiConfig","_wagmiConfig","queryOptions","estimateFeesPerGasQueryOptions","gasFeeResponse","ensureQueryData"],"mappings":";;;;;AAoBO,MAAMA,yBAAAA,GACXA,CAACC,OAAAA,GAAU,OACX,OAAO;AAAA,EAAEC,OAAAA;AAAAA,EAASC,IAAAA,GAAO;AAAU,CAAA,KAAM;AACvC,EAAA,MAAM;AAAA,iBAAEC,aAAAA,GAAcC,WAAAA;AAAAA,iBAAcC,aAAAA,GAAcC;AAAAA,GAAa,GAAIN,OAAAA;AAEnE,EAAA,MAAMO,YAAAA,GAAeC,+BAA+BH,aAAAA,EAAa;AAAA,IAC/DJ,OAAAA;AAAAA,IACAC;AAAAA,GACD,CAAA;AAED,EAAA,MAAMO,cAAAA,GAAiB,MAAMN,aAAAA,CAAYO,eAAAA,CAAgBH,YAAY,CAAA;AAErE,EAAA,OAAOE,cAAAA;AACT;;;;"}

package/dist/transactions/queries/ensureTxReceipt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ensureTxReceipt.d.ts","sourceRoot":"","sources":["../../../src/transactions/queries/ensureTxReceipt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE3E,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAI3E,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,cAAc,CAAC;AAU1C,KAAK,YAAY,GAAG,CAAC,IAAI,EAAE,qBAAqB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;AAEjE,MAAM,MAAM,iBAAiB,GAAG,CAC9B,OAAO,EAAE,YAAY,CACnB,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,SAAS,GAAG,eAAe,CAAC,EAChE,MAAM,GAAG,SAAS,CACnB,GAAG;IACF,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B,KACE,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,KAAK,sBAAsB,GAAG,CAAC,MAAM,CAAC,EAAE;IACtC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,YAAY,CAAC;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,KAAK,iBAAiB,CAAC;AAIxB,eAAO,MAAM,sBAAsB,EAAE,sBAiHlC,CAAC"}
+{"version":3,"file":"ensureTxReceipt.d.ts","sourceRoot":"","sources":["../../../src/transactions/queries/ensureTxReceipt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAE3E,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAU,KAAK,YAAY,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAI3E,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,cAAc,CAAC;AAU1C,KAAK,YAAY,GAAG,CAAC,IAAI,EAAE,qBAAqB,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC;AAEjE,MAAM,MAAM,iBAAiB,GAAG,CAC9B,OAAO,EAAE,YAAY,CACnB,IAAI,CAAC,oBAAoB,EAAE,MAAM,GAAG,SAAS,GAAG,eAAe,CAAC,EAChE,MAAM,GAAG,SAAS,CACnB,GAAG;IACF,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B,KACE,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,KAAK,sBAAsB,GAAG,CAAC,MAAM,CAAC,EAAE;IACtC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,YAAY,CAAC;IAClC,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,KAAK,iBAAiB,CAAC;AAIxB,eAAO,MAAM,sBAAsB,EAAE,sBAmHlC,CAAC"}

package/dist/transactions/queries/ensureTxReceipt.js

@@ -38,7 +38,7 @@ const ensureTxReceiptFactory = (options = {}) => async ({
   }
   const isConnectedToSafe = isWConnectConnectorWithSafe || isConnectedToSafeIframe;
   const isSafe = _isSafe || isConnectedToSafe;
-  const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : void 0;
+  const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : SAFE_CALLS_WAIT_TIMEOUT / 2;
   let config = wagmiConfig$1;
   let realtxHash = hash;
   if (isConnectedToSafeIframe) {

package/dist/transactions/queries/ensureTxReceipt.js.map

@@ -1 +1 @@
-{"version":3,"file":"ensureTxReceipt.js","sources":["../../../src/transactions/queries/ensureTxReceipt.ts"],"sourcesContent":["import type { UseAwaitTxParameters } from \"@/hooks/txs/queries/useAwaitTx\";\nimport { queryClient as _queryClient } from \"@/lib/queryClient\";\nimport { wagmiConfig as _wagmiConfig } from \"@/lib/web3/wagmi/config\";\nimport type { QueryClient } from \"@tanstack/react-query\";\n\nimport { assert, type MarkRequired } from \"ts-essentials\";\nimport { type ReplacementReturnType, type TransactionReceipt } from \"viem\";\n\nimport { waitForTransactionReceiptQueryOptions } from \"wagmi/query\";\nimport { SAFE_CALLS_WAIT_TIMEOUT } from \"@/lib/constants\";\nimport { type Chain } from \"wagmi/chains\";\nimport { getAccount, getConnectorClient } from \"@wagmi/core\";\nimport {\n  isConnectorWithSafeIframeProvider,\n  isExternalConnectorSafeWalletConnect,\n} from \"@/components/web3/ConnectExternalProvider/utils\";\nimport { isWalletConnectConnectorWithSafe } from \"@/hooks/connectors/useIsSafeThroughWalletConnect\";\nimport { ensureCallsStatusFactory } from \"./ensureCallsStatus\";\nimport { createLogger } from \"@/lib/utils/logger\";\n\ntype OnReplacedCb = (data: ReplacementReturnType<Chain>) => void;\n\nexport type EnsureTxReceiptFn = (\n  options: MarkRequired<\n    Pick<UseAwaitTxParameters, \"hash\" | \"chainId\" | \"confirmations\">,\n    \"hash\" | \"chainId\"\n  > & {\n    onReplaced?: OnReplacedCb;\n  }\n) => Promise<TransactionReceipt>;\n\ntype EnsureTxReceiptFactory = (params?: {\n  queryClient?: QueryClient;\n  wagmiConfig?: typeof _wagmiConfig;\n  isSafe?: boolean;\n}) => EnsureTxReceiptFn;\n\nconst logger = createLogger(\"Transactions:EnsureTxReceipt\");\n\nexport const ensureTxReceiptFactory: EnsureTxReceiptFactory =\n  (options = {}) =>\n  async ({ hash, chainId, confirmations, onReplaced }) => {\n    const {\n      queryClient = _queryClient,\n      wagmiConfig = _wagmiConfig,\n      isSafe: _isSafe,\n    } = options;\n    const { connector } = getAccount(wagmiConfig);\n    let isWConnectConnectorWithSafe = false;\n    let isConnectedToSafeIframe = false;\n    if (connector) {\n      isWConnectConnectorWithSafe =\n        // can determine sync from connector.type and connector.id in case of external provider\n        isExternalConnectorSafeWalletConnect(connector);\n      // can determine sync from connector.type and connector.id in case of Safe Iframe provider,\n      // whether as external provider or in safe connector\n      isConnectedToSafeIframe = isConnectorWithSafeIframeProvider(connector);\n      if (!isWConnectConnectorWithSafe && !isConnectedToSafeIframe) {\n        // neither External Safe WalletConnect connector nor Safe Iframe connector,\n        // so we check if it's a WalletConnect connector with Safe\n        isWConnectConnectorWithSafe =\n          await isWalletConnectConnectorWithSafe(connector);\n      }\n    }\n    const isConnectedToSafe =\n      isWConnectConnectorWithSafe || isConnectedToSafeIframe;\n\n    const isSafe = _isSafe || isConnectedToSafe;\n\n    const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : undefined;\n\n    let config = wagmiConfig;\n    let realtxHash = hash;\n\n    // always use connector client if connected through native safe connector.\n    // safe provider returns a safeTxHash that is different from a real tx hash.\n    // if connected to safe through WalletConnect - publicClient returns a real tx hash.\n    if (isConnectedToSafeIframe) {\n      const safeClient = await getConnectorClient(wagmiConfig, {\n        chainId,\n        connector,\n      });\n\n      // force waitForTransactionReceiptQueryOptions to use SafeClient internally\n      config = {\n        ...wagmiConfig,\n        // doesn't work with Safe through WalletConnect connector\n        getClient: (options) => {\n          assert(!options || options.chainId === chainId, \"chainId mismatch\");\n          return safeClient;\n        },\n      } as typeof wagmiConfig;\n    } else if (isWConnectConnectorWithSafe) {\n      /**\n       * When Safe is connected through WalletConnect\n       * (whether as external provider or in WalletConnect connector),\n       * the resulting provider only ever returns safeTxHash in response to eth_sendTransaction.\n       * And the provider never returns  any kind of result in response to eth_getTransactionReceipt\n       * or eth_getTransactionByHash for that safeTxHash.\n       * Safe iframe provider does return real txHash's receipt in response to eth_getTransactionReceipt for safeTxHash.\n       * But Safe through WalletConnect never does that.\n       * Options:\n       * 1. Use deprecated Safe API v1 to get the real tx hash and await its receipt\n       * 2. Use Safe API v2 (optionally through safe-api-kit) but there an API key is required\n       * 3. Safe SDK isn't an option as it communicates with Safe only from inside an iframe\n       * 4. Surprisingly, wallet_getCallsStatus works with safeTxHash (at least with multiple signers)\n       *\n       * Here we go with option 4:\n       * sendCallsId=safeTxHash -> getCallsStatus -> realTxHash=callsReceipt.txHash -> await receipt of realTxHash\n       *\n       * refs:\n       * https://github.com/safe-global/safe-react-apps/issues/712\n       * https://github.com/safe-global/safe-react-apps/issues/62\n       */\n      const ensureCallsStatus = ensureCallsStatusFactory({\n        ...options,\n        isSafe: true,\n      });\n      try {\n        const callsStatusResult = await ensureCallsStatus({ id: hash });\n        const classReceipt =\n          callsStatusResult.receipts?.[callsStatusResult.receipts.length - 1];\n\n        assert(\n          classReceipt,\n          `Transaction receipt not found for Safe tx through WalletConnect ${hash}, on chain ${chainId}`\n        );\n\n        realtxHash = classReceipt.transactionHash;\n      } catch (error) {\n        // it is possible Safe through WalletConnect could be connected but called with a past non-Safe tx from localStorage,\n        // in that case we should try to get the tx receipt normally\n        logger.error(\n          \"Error getting calls status for Safe tx through WalletConnect\",\n          { error }\n        );\n      }\n    }\n\n    // wagmi/core waitForTransactionReceipt throws on receipt.status==\"reverted\",\n    // unlike viem waitForTransactionReceipt which returns the receipt as is\n    const queryOptions = waitForTransactionReceiptQueryOptions(config, {\n      hash: realtxHash,\n      chainId,\n      confirmations,\n      timeout,\n      onReplaced,\n    });\n\n    const receipt = await queryClient.ensureQueryData(queryOptions);\n\n    return receipt;\n  };\n"],"names":["logger","createLogger","ensureTxReceiptFactory","options","hash","chainId","confirmations","onReplaced","queryClient","_queryClient","wagmiConfig","_wagmiConfig","isSafe","_isSafe","connector","getAccount","isWConnectConnectorWithSafe","isConnectedToSafeIframe","isExternalConnectorSafeWalletConnect","isConnectorWithSafeIframeProvider","isWalletConnectConnectorWithSafe","isConnectedToSafe","timeout","SAFE_CALLS_WAIT_TIMEOUT","undefined","config","realtxHash","safeClient","getConnectorClient","getClient","assert","ensureCallsStatus","ensureCallsStatusFactory","callsStatusResult","id","classReceipt","receipts","length","transactionHash","error","queryOptions","waitForTransactionReceiptQueryOptions","receipt","ensureQueryData"],"mappings":"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"}
+{"version":3,"file":"ensureTxReceipt.js","sources":["../../../src/transactions/queries/ensureTxReceipt.ts"],"sourcesContent":["import type { UseAwaitTxParameters } from \"@/hooks/txs/queries/useAwaitTx\";\nimport { queryClient as _queryClient } from \"@/lib/queryClient\";\nimport { wagmiConfig as _wagmiConfig } from \"@/lib/web3/wagmi/config\";\nimport type { QueryClient } from \"@tanstack/react-query\";\n\nimport { assert, type MarkRequired } from \"ts-essentials\";\nimport { type ReplacementReturnType, type TransactionReceipt } from \"viem\";\n\nimport { waitForTransactionReceiptQueryOptions } from \"wagmi/query\";\nimport { SAFE_CALLS_WAIT_TIMEOUT } from \"@/lib/constants\";\nimport { type Chain } from \"wagmi/chains\";\nimport { getAccount, getConnectorClient } from \"@wagmi/core\";\nimport {\n  isConnectorWithSafeIframeProvider,\n  isExternalConnectorSafeWalletConnect,\n} from \"@/components/web3/ConnectExternalProvider/utils\";\nimport { isWalletConnectConnectorWithSafe } from \"@/hooks/connectors/useIsSafeThroughWalletConnect\";\nimport { ensureCallsStatusFactory } from \"./ensureCallsStatus\";\nimport { createLogger } from \"@/lib/utils/logger\";\n\ntype OnReplacedCb = (data: ReplacementReturnType<Chain>) => void;\n\nexport type EnsureTxReceiptFn = (\n  options: MarkRequired<\n    Pick<UseAwaitTxParameters, \"hash\" | \"chainId\" | \"confirmations\">,\n    \"hash\" | \"chainId\"\n  > & {\n    onReplaced?: OnReplacedCb;\n  }\n) => Promise<TransactionReceipt>;\n\ntype EnsureTxReceiptFactory = (params?: {\n  queryClient?: QueryClient;\n  wagmiConfig?: typeof _wagmiConfig;\n  isSafe?: boolean;\n}) => EnsureTxReceiptFn;\n\nconst logger = createLogger(\"Transactions:EnsureTxReceipt\");\n\nexport const ensureTxReceiptFactory: EnsureTxReceiptFactory =\n  (options = {}) =>\n  async ({ hash, chainId, confirmations, onReplaced }) => {\n    const {\n      queryClient = _queryClient,\n      wagmiConfig = _wagmiConfig,\n      isSafe: _isSafe,\n    } = options;\n    const { connector } = getAccount(wagmiConfig);\n    let isWConnectConnectorWithSafe = false;\n    let isConnectedToSafeIframe = false;\n    if (connector) {\n      isWConnectConnectorWithSafe =\n        // can determine sync from connector.type and connector.id in case of external provider\n        isExternalConnectorSafeWalletConnect(connector);\n      // can determine sync from connector.type and connector.id in case of Safe Iframe provider,\n      // whether as external provider or in safe connector\n      isConnectedToSafeIframe = isConnectorWithSafeIframeProvider(connector);\n      if (!isWConnectConnectorWithSafe && !isConnectedToSafeIframe) {\n        // neither External Safe WalletConnect connector nor Safe Iframe connector,\n        // so we check if it's a WalletConnect connector with Safe\n        isWConnectConnectorWithSafe =\n          await isWalletConnectConnectorWithSafe(connector);\n      }\n    }\n    const isConnectedToSafe =\n      isWConnectConnectorWithSafe || isConnectedToSafeIframe;\n\n    const isSafe = _isSafe || isConnectedToSafe;\n\n    const timeout = isSafe\n      ? SAFE_CALLS_WAIT_TIMEOUT\n      : SAFE_CALLS_WAIT_TIMEOUT / 2; // by default timeout is set to 0 inside waitForTransactionReceipt,\n    // which makes the receipt query never resolve if the tx is dropped\n\n    let config = wagmiConfig;\n    let realtxHash = hash;\n\n    // always use connector client if connected through native safe connector.\n    // safe provider returns a safeTxHash that is different from a real tx hash.\n    if (isConnectedToSafeIframe) {\n      const safeClient = await getConnectorClient(wagmiConfig, {\n        chainId,\n        connector,\n      });\n\n      // force waitForTransactionReceiptQueryOptions to use SafeClient internally\n      config = {\n        ...wagmiConfig,\n        // doesn't work with Safe through WalletConnect connector\n        getClient: (options) => {\n          assert(!options || options.chainId === chainId, \"chainId mismatch\");\n          return safeClient;\n        },\n      } as typeof wagmiConfig;\n    } else if (isWConnectConnectorWithSafe) {\n      /**\n       * When Safe is connected through WalletConnect\n       * (whether as external provider or in WalletConnect connector),\n       * the resulting provider only ever returns safeTxHash in response to eth_sendTransaction.\n       * And the provider never returns  any kind of result in response to eth_getTransactionReceipt\n       * or eth_getTransactionByHash for that safeTxHash.\n       * Safe iframe provider does return real txHash's receipt in response to eth_getTransactionReceipt for safeTxHash.\n       * But Safe through WalletConnect never does that.\n       * Options:\n       * 1. Use deprecated Safe API v1 to get the real tx hash and await its receipt\n       * 2. Use Safe API v2 (optionally through safe-api-kit) but there an API key is required\n       * 3. Safe SDK isn't an option as it communicates with Safe only from inside an iframe\n       * 4. Surprisingly, wallet_getCallsStatus works with safeTxHash (at least with multiple signers)\n       *\n       * Here we go with option 4:\n       * sendCallsId=safeTxHash -> getCallsStatus -> realTxHash=callsReceipt.txHash -> await receipt of realTxHash\n       *\n       * refs:\n       * https://github.com/safe-global/safe-react-apps/issues/712\n       * https://github.com/safe-global/safe-react-apps/issues/62\n       */\n      const ensureCallsStatus = ensureCallsStatusFactory({\n        ...options,\n        isSafe: true,\n      });\n      try {\n        const callsStatusResult = await ensureCallsStatus({ id: hash });\n        const classReceipt =\n          callsStatusResult.receipts?.[callsStatusResult.receipts.length - 1];\n\n        assert(\n          classReceipt,\n          `Transaction receipt not found for Safe tx through WalletConnect ${hash}, on chain ${chainId}`\n        );\n\n        realtxHash = classReceipt.transactionHash;\n      } catch (error) {\n        // it is possible Safe through WalletConnect could be connected but called with a past non-Safe tx from localStorage,\n        // in that case we should try to get the tx receipt normally\n        logger.error(\n          \"Error getting calls status for Safe tx through WalletConnect\",\n          { error }\n        );\n      }\n    }\n\n    // wagmi/core waitForTransactionReceipt throws on receipt.status==\"reverted\",\n    // unlike viem waitForTransactionReceipt which returns the receipt as is\n    const queryOptions = waitForTransactionReceiptQueryOptions(config, {\n      hash: realtxHash,\n      chainId,\n      confirmations,\n      timeout,\n      onReplaced,\n    });\n\n    const receipt = await queryClient.ensureQueryData(queryOptions);\n\n    return receipt;\n  };\n"],"names":["logger","createLogger","ensureTxReceiptFactory","options","hash","chainId","confirmations","onReplaced","queryClient","_queryClient","wagmiConfig","_wagmiConfig","isSafe","_isSafe","connector","getAccount","isWConnectConnectorWithSafe","isConnectedToSafeIframe","isExternalConnectorSafeWalletConnect","isConnectorWithSafeIframeProvider","isWalletConnectConnectorWithSafe","isConnectedToSafe","timeout","SAFE_CALLS_WAIT_TIMEOUT","config","realtxHash","safeClient","getConnectorClient","getClient","assert","ensureCallsStatus","ensureCallsStatusFactory","callsStatusResult","id","classReceipt","receipts","length","transactionHash","error","queryOptions","waitForTransactionReceiptQueryOptions","receipt","ensureQueryData"],"mappings":"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"}

package/dist/transactions/queries/ensureTxResponse.d.ts

@@ -0,0 +1,17 @@
+import { wagmiConfig as _wagmiConfig } from '../../lib/web3/wagmi/config';
+import { QueryClient } from '@tanstack/react-query';
+import { Hash } from 'viem';
+import { SupportedChainId } from '../../lib/web3/wagmi/types';
+import { GetTransactionReturnType } from '@wagmi/core';
+export type TxResponse = GetTransactionReturnType<typeof _wagmiConfig, SupportedChainId>;
+export type EnsureTxResponseFn = (options: {
+    hash: Hash;
+    chainId: SupportedChainId;
+}) => Promise<TxResponse>;
+type EnsureTxResponseFactory = (params?: {
+    queryClient?: QueryClient;
+    wagmiConfig?: typeof _wagmiConfig;
+}) => EnsureTxResponseFn;
+export declare const ensureTxResponseFactory: EnsureTxResponseFactory;
+export {};
+//# sourceMappingURL=ensureTxResponse.d.ts.map

package/dist/transactions/queries/ensureTxResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureTxResponse.d.ts","sourceRoot":"","sources":["../../../src/transactions/queries/ensureTxResponse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,MAAM,CAAC;AAGjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D,MAAM,MAAM,UAAU,GAAG,wBAAwB,CAC/C,OAAO,YAAY,EACnB,gBAAgB,CACjB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,EAAE;IACzC,IAAI,EAAE,IAAI,CAAC;IACX,OAAO,EAAE,gBAAgB,CAAC;CAC3B,KAAK,OAAO,CAAC,UAAU,CAAC,CAAC;AAE1B,KAAK,uBAAuB,GAAG,CAAC,MAAM,CAAC,EAAE;IACvC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,YAAY,CAAC;CACnC,KAAK,kBAAkB,CAAC;AAEzB,eAAO,MAAM,uBAAuB,EAAE,uBAenC,CAAC"}

package/dist/transactions/queries/ensureTxResponse.js

@@ -0,0 +1,23 @@
+import { queryClient } from '../../lib/queryClient.js';
+import { wagmiConfig } from '../../lib/web3/wagmi/config.js';
+import 'viem';
+import { getTransactionQueryOptions } from 'wagmi/query';
+
+const ensureTxResponseFactory = (options = {}) => async ({
+  hash,
+  chainId
+}) => {
+  const {
+    queryClient: queryClient$1 = queryClient,
+    wagmiConfig: wagmiConfig$1 = wagmiConfig
+  } = options;
+  const queryOptions = getTransactionQueryOptions(wagmiConfig$1, {
+    hash,
+    chainId
+  });
+  const txResponse = await queryClient$1.ensureQueryData(queryOptions);
+  return txResponse;
+};
+
+export { ensureTxResponseFactory };
+//# sourceMappingURL=ensureTxResponse.js.map

package/dist/transactions/queries/ensureTxResponse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensureTxResponse.js","sources":["../../../src/transactions/queries/ensureTxResponse.ts"],"sourcesContent":["import { queryClient as _queryClient } from \"@/lib/queryClient\";\nimport { wagmiConfig as _wagmiConfig } from \"@/lib/web3/wagmi/config\";\nimport type { QueryClient } from \"@tanstack/react-query\";\n\nimport { type Hash } from \"viem\";\n\nimport { getTransactionQueryOptions } from \"wagmi/query\";\nimport type { SupportedChainId } from \"@/lib/web3/wagmi/types\";\nimport type { GetTransactionReturnType } from \"@wagmi/core\";\n\nexport type TxResponse = GetTransactionReturnType<\n  typeof _wagmiConfig,\n  SupportedChainId\n>;\n\nexport type EnsureTxResponseFn = (options: {\n  hash: Hash;\n  chainId: SupportedChainId;\n}) => Promise<TxResponse>;\n\ntype EnsureTxResponseFactory = (params?: {\n  queryClient?: QueryClient;\n  wagmiConfig?: typeof _wagmiConfig;\n}) => EnsureTxResponseFn;\n\nexport const ensureTxResponseFactory: EnsureTxResponseFactory =\n  (options = {}) =>\n  async ({ hash, chainId }) => {\n    const { queryClient = _queryClient, wagmiConfig = _wagmiConfig } = options;\n\n    // wagmi/core getTransaction throws TransactionNotFoundError when no tx found\n    const queryOptions = getTransactionQueryOptions(wagmiConfig, {\n      hash,\n      chainId,\n    });\n\n    const txResponse: TxResponse =\n      await queryClient.ensureQueryData(queryOptions);\n\n    return txResponse;\n  };\n"],"names":["ensureTxResponseFactory","options","hash","chainId","queryClient","_queryClient","wagmiConfig","_wagmiConfig","queryOptions","getTransactionQueryOptions","txResponse","ensureQueryData"],"mappings":";;;;;AAyBO,MAAMA,uBAAAA,GACXA,CAACC,OAAAA,GAAU,OACX,OAAO;AAAA,EAAEC,IAAAA;AAAAA,EAAMC;AAAQ,CAAA,KAAM;AAC3B,EAAA,MAAM;AAAA,iBAAEC,aAAAA,GAAcC,WAAAA;AAAAA,iBAAcC,aAAAA,GAAcC;AAAAA,GAAa,GAAIN,OAAAA;AAGnE,EAAA,MAAMO,YAAAA,GAAeC,2BAA2BH,aAAAA,EAAa;AAAA,IAC3DJ,IAAAA;AAAAA,IACAC;AAAAA,GACD,CAAA;AAED,EAAA,MAAMO,UAAAA,GACJ,MAAMN,aAAAA,CAAYO,eAAAA,CAAgBH,YAAY,CAAA;AAEhD,EAAA,OAAOE,UAAAA;AACT;;;;"}

package/dist/transactions/state/hooks/useMarkTxAsDropped.d.ts

@@ -0,0 +1,7 @@
+export declare function useMarkTxAsDropped(): (args_0: {
+    account: import('viem').Address;
+    txHash: import('viem').Hash;
+    action?: import('../../../hooks/txs/mutations/useReplaceTx').ReplacementTxAction;
+    replacementTxHash?: import('viem').Hash;
+}) => void;
+//# sourceMappingURL=useMarkTxAsDropped.d.ts.map

package/dist/transactions/state/hooks/useMarkTxAsDropped.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMarkTxAsDropped.d.ts","sourceRoot":"","sources":["../../../../src/transactions/state/hooks/useMarkTxAsDropped.ts"],"names":[],"mappings":"AAGA,wBAAgB,kBAAkB;;;;;WAIjC"}

package/dist/transactions/state/hooks/useMarkTxAsDropped.js

@@ -0,0 +1,10 @@
+import { useSetAtom } from '../../../core/store.js';
+import { markTxAsDroppedAtom } from '../transactionsActionAtom.js';
+
+function useMarkTxAsDropped() {
+  const markTxAsDropped = useSetAtom(markTxAsDroppedAtom);
+  return markTxAsDropped;
+}
+
+export { useMarkTxAsDropped };
+//# sourceMappingURL=useMarkTxAsDropped.js.map

package/dist/transactions/state/hooks/useMarkTxAsDropped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMarkTxAsDropped.js","sources":["../../../../src/transactions/state/hooks/useMarkTxAsDropped.ts"],"sourcesContent":["import { useSetAtom } from \"@/core/store\";\nimport { markTxAsDroppedAtom } from \"../transactionsActionAtom\";\n\nexport function useMarkTxAsDropped() {\n  const markTxAsDropped = useSetAtom(markTxAsDroppedAtom);\n\n  return markTxAsDropped;\n}\n"],"names":["useMarkTxAsDropped","markTxAsDropped","useSetAtom","markTxAsDroppedAtom"],"mappings":";;;AAGO,SAAAA,kBAAAA,GAAA;AACL,EAAA,MAAAC,eAAAA,GAAwBC,WAAWC,mBAAmB,CAAA;AAAE,EAAA,OAEjDF,eAAAA;AAAe;;;;"}

package/dist/transactions/state/transactionsActionAtom.d.ts

@@ -1,4 +1,6 @@
 import { StandaloneTransactionItem, BatchTransactionItem, MinTransactionItem } from '../types';
+import { Hash, Address } from 'viem';
+import { ReplacementTxAction } from '../../hooks/txs/mutations/useReplaceTx';
 export declare const addTxAtom: import('jotai').WritableAtom<null, [transaction: MinTransactionItem], void> & {
     init: null;
 };
@@ -9,4 +11,14 @@ export declare const finalizeBatchTxAtom: import('jotai').WritableAtom<null, [Ba
     init: null;
 };
 export declare const addTx: (transaction: MinTransactionItem) => Promise<void>;
+type MarkTxAsDroppedOptions = {
+    account: Address;
+    txHash: Hash;
+    action?: ReplacementTxAction;
+    replacementTxHash?: Hash;
+};
+export declare const markTxAsDroppedAtom: import('jotai').WritableAtom<null, [MarkTxAsDroppedOptions], void> & {
+    init: null;
+};
+export {};
 //# sourceMappingURL=transactionsActionAtom.d.ts.map

package/dist/transactions/state/transactionsActionAtom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transactionsActionAtom.d.ts","sourceRoot":"","sources":["../../../src/transactions/state/transactionsActionAtom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,UAAU,CAAC;AA+BlB,eAAO,MAAM,SAAS;;CAoCrB,CAAC;AAEF,eAAO,MAAM,wBAAwB;;CAwCnC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;CA8B9B,CAAC;AAEH,eAAO,MAAM,KAAK,GAAU,aAAa,kBAAkB,kBAE1D,CAAC"}
+{"version":3,"file":"transactionsActionAtom.d.ts","sourceRoot":"","sources":["../../../src/transactions/state/transactionsActionAtom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,UAAU,CAAC;AAMlB,OAAO,EAML,KAAK,IAAI,EACT,KAAK,OAAO,EACb,MAAM,MAAM,CAAC;AAkBd,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,eAAO,MAAM,SAAS;;CAoCrB,CAAC;AAEF,eAAO,MAAM,wBAAwB;;CAwCnC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;CA8B9B,CAAC;AAEH,eAAO,MAAM,KAAK,GAAU,aAAa,kBAAkB,kBAE1D,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,IAAI,CAAC;IACb,MAAM,CAAC,EAAE,mBAAmB,CAAC;IAC7B,iBAAiB,CAAC,EAAE,IAAI,CAAC;CAC1B,CAAC;AAEF,eAAO,MAAM,mBAAmB;;CAoC/B,CAAC"}

package/dist/transactions/state/transactionsActionAtom.js

@@ -120,6 +120,39 @@ const finalizeBatchTxAtom = atom(null, async (_, set, transaction) => {
 const addTx = async (transaction) => {
   return jotaiStore.set(addTxAtom, transaction);
 };
+const markTxAsDroppedAtom = atom(null, (_, set, options) => {
+  const {
+    txHash,
+    action,
+    replacementTxHash,
+    account
+  } = options;
+  set(transactionsAtom, (currentTransactions) => {
+    const accountTransactions = currentTransactions[account] || {};
+    const identifier = txHash;
+    const txItem = accountTransactions[identifier];
+    if (!txItem) return currentTransactions;
+    if (!isStandaloneTransactionItem(txItem)) return currentTransactions;
+    const updatedTxItem = {
+      ...txItem,
+      dropped: true
+    };
+    if (action && replacementTxHash) {
+      updatedTxItem.replacementTx = {
+        hash: replacementTxHash,
+        action
+      };
+    }
+    const updatedAccountTransactions = {
+      ...accountTransactions,
+      [identifier]: updatedTxItem
+    };
+    return {
+      ...currentTransactions,
+      [account]: updatedAccountTransactions
+    };
+  });
+});
 function sanitizeTx(tx) {
   if (isBatchTransactionItem(tx)) {
     const txItem2 = {
@@ -161,6 +194,12 @@ function sanitizeTx(tx) {
       isSafe: tx.connectorData.isSafe ?? isGnosisSafeTx(tx)
     };
   }
+  if (tx.replacementTx) {
+    txItem.replacementTx = {
+      hash: tx.replacementTx.hash,
+      action: tx.replacementTx.action
+    };
+  }
   return txItem;
 }
 function assignTx(currentTransactions, transaction) {
@@ -183,5 +222,5 @@ function assignTx(currentTransactions, transaction) {
   };
 }
 
-export { addTx, addTxAtom, finalizeBatchTxAtom, finalizeStandaloneTxAtom };
+export { addTx, addTxAtom, finalizeBatchTxAtom, finalizeStandaloneTxAtom, markTxAsDroppedAtom };
 //# sourceMappingURL=transactionsActionAtom.js.map

package/dist/transactions/state/transactionsActionAtom.js.map

@@ -1 +1 @@
-{"version":3,"file":"transactionsActionAtom.js","sources":["../../../src/transactions/state/transactionsActionAtom.ts"],"sourcesContent":["import type {\n  TransactionItem,\n  StandaloneTransactionItem,\n  BatchTransactionItem,\n  MinTransactionItem,\n} from \"../types\";\nimport { atom } from \"jotai\";\nimport { jotaiStore } from \"@/core/store\";\n\nimport { ensureCallsStatusFactory } from \"../queries/ensureCallsStatus\";\nimport { ensureTxReceiptFactory } from \"../queries/ensureTxReceipt\";\nimport {\n  WaitForCallsStatusTimeoutError,\n  TransactionReceiptNotFoundError,\n  WaitForTransactionReceiptTimeoutError,\n  MethodNotSupportedRpcError,\n  CallExecutionError,\n} from \"viem\";\nimport { transactionLogger } from \"../logger\";\nimport {\n  transactionsAtom,\n  type TransactionsMap,\n  type TransactionsState,\n} from \"./transactionsAtom\";\nimport {\n  isBatchTransactionItem,\n  isGnosisSafeTx,\n  isStandaloneTransactionItem,\n} from \"../utils\";\nimport { assert } from \"ts-essentials\";\nimport {\n  accountAtom,\n  isConnectorWithSafeAsyncAtomLoadableAtom,\n} from \"@/lib/web3/wagmi/external\";\nimport { isConnectorWithSafeProvider } from \"@/components/web3/ConnectExternalProvider/utils\";\n\nexport const addTxAtom = atom<null, [transaction: MinTransactionItem], void>(\n  null,\n  (get, set, transaction) => {\n    const { connector, address } = get(accountAtom);\n    assert(connector && address, \"connector and address are required\");\n    let isSafe = isConnectorWithSafeProvider(connector);\n\n    if (!isSafe) {\n      // loadable is used to keep addition of txWithMeta to transactionsAtom sync,\n      // and avoid blocking addTxAtom setters\n      const loadableResult = get(isConnectorWithSafeAsyncAtomLoadableAtom);\n      if (loadableResult.state === \"hasData\" && loadableResult.data) {\n        isSafe = true;\n      }\n    }\n\n    const txWithMeta: TransactionItem = {\n      ...transaction,\n      account: address,\n      timestamp: Date.now(),\n      dropped: false,\n      connectorData: {\n        type: connector.type,\n        id: connector.id,\n        isSafe,\n      },\n    };\n    set(transactionsAtom, (current) => assignTx(current, txWithMeta));\n\n    if (isStandaloneTransactionItem(txWithMeta)) {\n      // don't await to avoid blocking addTxAtom setters\n      set(finalizeStandaloneTxAtom, txWithMeta);\n    } else {\n      set(finalizeBatchTxAtom, txWithMeta);\n    }\n  }\n);\n\nexport const finalizeStandaloneTxAtom = atom<\n  null,\n  [StandaloneTransactionItem],\n  Promise<void>\n>(null, async (_, set, transaction) => {\n  const finalizedTx: StandaloneTransactionItem = { ...transaction };\n  const ensureTxReceipt = ensureTxReceiptFactory();\n  const isTxThroughSafe = isGnosisSafeTx(finalizedTx);\n\n  try {\n    // ensureTxReceipt internally makes sure to use walletClient for Safe connector\n    const txReceipt = await ensureTxReceipt({\n      hash: finalizedTx.transactionHash,\n      chainId: finalizedTx.chainId,\n    });\n    finalizedTx.receipt = txReceipt;\n  } catch (error) {\n    if (\n      /* \n        At different steps of the waitForTransactionReceipt func different errors can be thrown.\n        And if tx turned in eth_call with the same params succeeds (which it normally should not if it reverted for a valid reason and not gas or something),\n        we can even get a useless Error(\"unknown reason\") or Error(\"0xrandom_hash\")\n      */\n      error instanceof WaitForTransactionReceiptTimeoutError || // thrown when transaction is not found within the timeout period\n      error instanceof TransactionReceiptNotFoundError || // thrown when transaction receipt is not found\n      error instanceof CallExecutionError // thrown when the transaction execution fails on-chain (execution reverted, out of gas, etc)\n    ) {\n      finalizedTx.dropped = true;\n      transactionLogger.error(\"tx dropped\", {\n        error,\n        finalizedTx,\n        isTxThroughSafe,\n      });\n    } else throw error;\n  } finally {\n    if (finalizedTx.receipt || finalizedTx.dropped) {\n      set(transactionsAtom, (current) => assignTx(current, finalizedTx));\n      transactionLogger.log(\"tx finalized\", { finalizedTx, isTxThroughSafe });\n    }\n  }\n});\n\nexport const finalizeBatchTxAtom = atom<\n  null,\n  [BatchTransactionItem],\n  Promise<void>\n>(null, async (_, set, transaction) => {\n  const finalizedTx: BatchTransactionItem = { ...transaction };\n  const ensureCallsStatus = ensureCallsStatusFactory();\n\n  try {\n    const { receipts, status } = await ensureCallsStatus({\n      id: finalizedTx.callsId,\n    });\n    finalizedTx.callsStatus = status;\n    finalizedTx.receipt = receipts?.[receipts.length - 1];\n  } catch (error) {\n    if (\n      error instanceof WaitForCallsStatusTimeoutError ||\n      error instanceof MethodNotSupportedRpcError\n    ) {\n      finalizedTx.dropped = true;\n      transactionLogger.error(\"batch tx dropped\", { error, finalizedTx });\n    } else {\n      finalizedTx.callsStatus = \"failure\";\n      transactionLogger.error(\"batch tx failed\", { error, finalizedTx });\n      throw error;\n    }\n  } finally {\n    set(transactionsAtom, (current) => assignTx(current, finalizedTx));\n    transactionLogger.log(\"batch tx finalized\", { finalizedTx });\n  }\n});\n\nexport const addTx = async (transaction: MinTransactionItem) => {\n  return jotaiStore.set(addTxAtom, transaction);\n};\n\nfunction sanitizeTx(tx: TransactionItem): TransactionItem {\n  if (isBatchTransactionItem(tx)) {\n    const txItem = {\n      action: tx.action,\n      account: tx.account,\n      chainId: tx.chainId,\n      callsId: tx.callsId,\n      callsStatus: tx.callsStatus,\n      timestamp: tx.timestamp,\n      dropped: tx.dropped,\n      receipt: tx.receipt,\n      transactionSpecificData: tx.transactionSpecificData,\n    } as BatchTransactionItem;\n\n    if (tx.connectorData) {\n      txItem.connectorData = {\n        type: tx.connectorData.type,\n        id: tx.connectorData.id,\n        // extra check for backwards compatibility with txs from localStorage without connectorData.isSafe\n        isSafe: tx.connectorData.isSafe ?? isGnosisSafeTx(tx),\n      };\n    }\n\n    return txItem;\n  }\n\n  const txItem = {\n    action: tx.action,\n    chainId: tx.chainId,\n    account: tx.account,\n    transactionHash: tx.transactionHash,\n    timestamp: tx.timestamp,\n    dropped: tx.dropped,\n    receipt: tx.receipt,\n    transactionSpecificData: tx.transactionSpecificData,\n  } as StandaloneTransactionItem;\n\n  if (tx.connectorData) {\n    txItem.connectorData = {\n      type: tx.connectorData.type,\n      id: tx.connectorData.id,\n      // extra check for backwards compatibility with txs from localStorage without connectorData.isSafe\n      isSafe: tx.connectorData.isSafe ?? isGnosisSafeTx(tx),\n    };\n  }\n\n  return txItem;\n}\n\nfunction assignTx(\n  currentTransactions: TransactionsState,\n  transaction: TransactionItem\n): TransactionsState {\n  transactionLogger.log(\"assignTx\", {\n    account: transaction.account,\n    transaction,\n  });\n\n  const accountTransactions = currentTransactions[transaction.account] || {};\n  const identifier = isStandaloneTransactionItem(transaction)\n    ? transaction.transactionHash\n    : transaction.callsId;\n\n  const updatedAccountTransactions: TransactionsMap = {\n    ...accountTransactions,\n    [identifier]: sanitizeTx({\n      ...accountTransactions[identifier],\n      ...transaction,\n    }),\n  };\n\n  return {\n    ...currentTransactions,\n    [transaction.account]: updatedAccountTransactions,\n  };\n}\n"],"names":["addTxAtom","atom","get","set","transaction","connector","address","accountAtom","assert","isSafe","isConnectorWithSafeProvider","loadableResult","isConnectorWithSafeAsyncAtomLoadableAtom","state","data","txWithMeta","account","timestamp","Date","now","dropped","connectorData","type","id","transactionsAtom","current","assignTx","isStandaloneTransactionItem","finalizeStandaloneTxAtom","finalizeBatchTxAtom","_","finalizedTx","ensureTxReceipt","ensureTxReceiptFactory","isTxThroughSafe","isGnosisSafeTx","txReceipt","hash","transactionHash","chainId","receipt","error","WaitForTransactionReceiptTimeoutError","TransactionReceiptNotFoundError","CallExecutionError","transactionLogger","log","ensureCallsStatus","ensureCallsStatusFactory","receipts","status","callsId","callsStatus","length","WaitForCallsStatusTimeoutError","MethodNotSupportedRpcError","addTx","jotaiStore","sanitizeTx","tx","isBatchTransactionItem","txItem","action","transactionSpecificData","currentTransactions","accountTransactions","identifier","updatedAccountTransactions"],"mappings":"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"}
+{"version":3,"file":"transactionsActionAtom.js","sources":["../../../src/transactions/state/transactionsActionAtom.ts"],"sourcesContent":["import type {\n  TransactionItem,\n  StandaloneTransactionItem,\n  BatchTransactionItem,\n  MinTransactionItem,\n} from \"../types\";\nimport { atom } from \"jotai\";\nimport { jotaiStore } from \"@/core/store\";\n\nimport { ensureCallsStatusFactory } from \"../queries/ensureCallsStatus\";\nimport { ensureTxReceiptFactory } from \"../queries/ensureTxReceipt\";\nimport {\n  WaitForCallsStatusTimeoutError,\n  TransactionReceiptNotFoundError,\n  WaitForTransactionReceiptTimeoutError,\n  MethodNotSupportedRpcError,\n  CallExecutionError,\n  type Hash,\n  type Address,\n} from \"viem\";\nimport { transactionLogger } from \"../logger\";\nimport {\n  transactionsAtom,\n  type TransactionsMap,\n  type TransactionsState,\n} from \"./transactionsAtom\";\nimport {\n  isBatchTransactionItem,\n  isGnosisSafeTx,\n  isStandaloneTransactionItem,\n} from \"../utils\";\nimport { assert } from \"ts-essentials\";\nimport {\n  accountAtom,\n  isConnectorWithSafeAsyncAtomLoadableAtom,\n} from \"@/lib/web3/wagmi/external\";\nimport { isConnectorWithSafeProvider } from \"@/components/web3/ConnectExternalProvider/utils\";\nimport type { ReplacementTxAction } from \"@/hooks/txs/mutations/useReplaceTx\";\n\nexport const addTxAtom = atom<null, [transaction: MinTransactionItem], void>(\n  null,\n  (get, set, transaction) => {\n    const { connector, address } = get(accountAtom);\n    assert(connector && address, \"connector and address are required\");\n    let isSafe = isConnectorWithSafeProvider(connector);\n\n    if (!isSafe) {\n      // loadable is used to keep addition of txWithMeta to transactionsAtom sync,\n      // and avoid blocking addTxAtom setters\n      const loadableResult = get(isConnectorWithSafeAsyncAtomLoadableAtom);\n      if (loadableResult.state === \"hasData\" && loadableResult.data) {\n        isSafe = true;\n      }\n    }\n\n    const txWithMeta: TransactionItem = {\n      ...transaction,\n      account: address,\n      timestamp: Date.now(),\n      dropped: false,\n      connectorData: {\n        type: connector.type,\n        id: connector.id,\n        isSafe,\n      },\n    };\n    set(transactionsAtom, (current) => assignTx(current, txWithMeta));\n\n    if (isStandaloneTransactionItem(txWithMeta)) {\n      // don't await to avoid blocking addTxAtom setters\n      set(finalizeStandaloneTxAtom, txWithMeta);\n    } else {\n      set(finalizeBatchTxAtom, txWithMeta);\n    }\n  }\n);\n\nexport const finalizeStandaloneTxAtom = atom<\n  null,\n  [StandaloneTransactionItem],\n  Promise<void>\n>(null, async (_, set, transaction) => {\n  const finalizedTx: StandaloneTransactionItem = { ...transaction };\n  const ensureTxReceipt = ensureTxReceiptFactory();\n  const isTxThroughSafe = isGnosisSafeTx(finalizedTx);\n\n  try {\n    // ensureTxReceipt internally makes sure to use walletClient for Safe connector\n    const txReceipt = await ensureTxReceipt({\n      hash: finalizedTx.transactionHash,\n      chainId: finalizedTx.chainId,\n    });\n    finalizedTx.receipt = txReceipt;\n  } catch (error) {\n    if (\n      /* \n        At different steps of the waitForTransactionReceipt func different errors can be thrown.\n        And if tx turned in eth_call with the same params succeeds (which it normally should not if it reverted for a valid reason and not gas or something),\n        we can even get a useless Error(\"unknown reason\") or Error(\"0xrandom_hash\")\n      */\n      error instanceof WaitForTransactionReceiptTimeoutError || // thrown when transaction is not found within the timeout period\n      error instanceof TransactionReceiptNotFoundError || // thrown when transaction receipt is not found\n      error instanceof CallExecutionError // thrown when the transaction execution fails on-chain (execution reverted, out of gas, etc)\n    ) {\n      finalizedTx.dropped = true;\n      transactionLogger.error(\"tx dropped\", {\n        error,\n        finalizedTx,\n        isTxThroughSafe,\n      });\n    } else throw error;\n  } finally {\n    if (finalizedTx.receipt || finalizedTx.dropped) {\n      set(transactionsAtom, (current) => assignTx(current, finalizedTx));\n      transactionLogger.log(\"tx finalized\", { finalizedTx, isTxThroughSafe });\n    }\n  }\n});\n\nexport const finalizeBatchTxAtom = atom<\n  null,\n  [BatchTransactionItem],\n  Promise<void>\n>(null, async (_, set, transaction) => {\n  const finalizedTx: BatchTransactionItem = { ...transaction };\n  const ensureCallsStatus = ensureCallsStatusFactory();\n\n  try {\n    const { receipts, status } = await ensureCallsStatus({\n      id: finalizedTx.callsId,\n    });\n    finalizedTx.callsStatus = status;\n    finalizedTx.receipt = receipts?.[receipts.length - 1];\n  } catch (error) {\n    if (\n      error instanceof WaitForCallsStatusTimeoutError ||\n      error instanceof MethodNotSupportedRpcError\n    ) {\n      finalizedTx.dropped = true;\n      transactionLogger.error(\"batch tx dropped\", { error, finalizedTx });\n    } else {\n      finalizedTx.callsStatus = \"failure\";\n      transactionLogger.error(\"batch tx failed\", { error, finalizedTx });\n      throw error;\n    }\n  } finally {\n    set(transactionsAtom, (current) => assignTx(current, finalizedTx));\n    transactionLogger.log(\"batch tx finalized\", { finalizedTx });\n  }\n});\n\nexport const addTx = async (transaction: MinTransactionItem) => {\n  return jotaiStore.set(addTxAtom, transaction);\n};\n\ntype MarkTxAsDroppedOptions = {\n  account: Address;\n  txHash: Hash;\n  action?: ReplacementTxAction;\n  replacementTxHash?: Hash;\n};\n\nexport const markTxAsDroppedAtom = atom<null, [MarkTxAsDroppedOptions], void>(\n  null,\n  (_, set, options) => {\n    const { txHash, action, replacementTxHash, account } = options;\n    set(transactionsAtom, (currentTransactions) => {\n      const accountTransactions = currentTransactions[account] || {};\n\n      const identifier = txHash;\n      const txItem = accountTransactions[identifier];\n      if (!txItem) return currentTransactions;\n      // only non-batch txs can be cancelled\n      if (!isStandaloneTransactionItem(txItem)) return currentTransactions;\n\n      const updatedTxItem: typeof txItem = {\n        ...txItem,\n        dropped: true,\n      };\n\n      if (action && replacementTxHash) {\n        updatedTxItem.replacementTx = {\n          hash: replacementTxHash,\n          action,\n        };\n      }\n\n      const updatedAccountTransactions: TransactionsMap = {\n        ...accountTransactions,\n        [identifier]: updatedTxItem,\n      };\n\n      return {\n        ...currentTransactions,\n        [account]: updatedAccountTransactions,\n      };\n    });\n  }\n);\n\nfunction sanitizeTx(tx: TransactionItem): TransactionItem {\n  if (isBatchTransactionItem(tx)) {\n    const txItem = {\n      action: tx.action,\n      account: tx.account,\n      chainId: tx.chainId,\n      callsId: tx.callsId,\n      callsStatus: tx.callsStatus,\n      timestamp: tx.timestamp,\n      dropped: tx.dropped,\n      receipt: tx.receipt,\n      transactionSpecificData: tx.transactionSpecificData,\n    } as BatchTransactionItem;\n\n    if (tx.connectorData) {\n      txItem.connectorData = {\n        type: tx.connectorData.type,\n        id: tx.connectorData.id,\n        // extra check for backwards compatibility with txs from localStorage without connectorData.isSafe\n        isSafe: tx.connectorData.isSafe ?? isGnosisSafeTx(tx),\n      };\n    }\n\n    return txItem;\n  }\n\n  const txItem = {\n    action: tx.action,\n    chainId: tx.chainId,\n    account: tx.account,\n    transactionHash: tx.transactionHash,\n    timestamp: tx.timestamp,\n    dropped: tx.dropped,\n    receipt: tx.receipt,\n    transactionSpecificData: tx.transactionSpecificData,\n  } as StandaloneTransactionItem;\n\n  if (tx.connectorData) {\n    txItem.connectorData = {\n      type: tx.connectorData.type,\n      id: tx.connectorData.id,\n      // extra check for backwards compatibility with txs from localStorage without connectorData.isSafe\n      isSafe: tx.connectorData.isSafe ?? isGnosisSafeTx(tx),\n    };\n  }\n\n  if (tx.replacementTx) {\n    txItem.replacementTx = {\n      hash: tx.replacementTx.hash,\n      action: tx.replacementTx.action,\n    };\n  }\n\n  return txItem;\n}\n\nfunction assignTx(\n  currentTransactions: TransactionsState,\n  transaction: TransactionItem\n): TransactionsState {\n  transactionLogger.log(\"assignTx\", {\n    account: transaction.account,\n    transaction,\n  });\n\n  const accountTransactions = currentTransactions[transaction.account] || {};\n  const identifier = isStandaloneTransactionItem(transaction)\n    ? transaction.transactionHash\n    : transaction.callsId;\n\n  const updatedAccountTransactions: TransactionsMap = {\n    ...accountTransactions,\n    [identifier]: sanitizeTx({\n      ...accountTransactions[identifier],\n      ...transaction,\n    }),\n  };\n\n  return {\n    ...currentTransactions,\n    [transaction.account]: updatedAccountTransactions,\n  };\n}\n"],"names":["addTxAtom","atom","get","set","transaction","connector","address","accountAtom","assert","isSafe","isConnectorWithSafeProvider","loadableResult","isConnectorWithSafeAsyncAtomLoadableAtom","state","data","txWithMeta","account","timestamp","Date","now","dropped","connectorData","type","id","transactionsAtom","current","assignTx","isStandaloneTransactionItem","finalizeStandaloneTxAtom","finalizeBatchTxAtom","_","finalizedTx","ensureTxReceipt","ensureTxReceiptFactory","isTxThroughSafe","isGnosisSafeTx","txReceipt","hash","transactionHash","chainId","receipt","error","WaitForTransactionReceiptTimeoutError","TransactionReceiptNotFoundError","CallExecutionError","transactionLogger","log","ensureCallsStatus","ensureCallsStatusFactory","receipts","status","callsId","callsStatus","length","WaitForCallsStatusTimeoutError","MethodNotSupportedRpcError","addTx","jotaiStore","markTxAsDroppedAtom","options","txHash","action","replacementTxHash","currentTransactions","accountTransactions","identifier","txItem","updatedTxItem","replacementTx","updatedAccountTransactions","sanitizeTx","tx","isBatchTransactionItem","transactionSpecificData"],"mappings":"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"}

package/dist/transactions/status.d.ts

@@ -1,5 +1,5 @@
 import { TransactionReceipt } from 'viem';
 import { TransactionItem } from './types';
-export type TxStatus = TransactionReceipt["status"] | "pending";
+export type TxStatus = TransactionReceipt["status"] | "pending" | "cancelled";
 export declare function getTxStatus(tx: TransactionItem): TxStatus;
 //# sourceMappingURL=status.d.ts.map

package/dist/transactions/status.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/transactions/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C,MAAM,MAAM,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;AAEhE,wBAAgB,WAAW,CAAC,EAAE,EAAE,eAAe,GAAG,QAAQ,CAKzD"}
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/transactions/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG/C,MAAM,MAAM,QAAQ,GAAG,kBAAkB,CAAC,QAAQ,CAAC,GAAG,SAAS,GAAG,WAAW,CAAC;AAE9E,wBAAgB,WAAW,CAAC,EAAE,EAAE,eAAe,GAAG,QAAQ,CAUzD"}

package/dist/transactions/status.js

@@ -1,5 +1,11 @@
+import { isStandaloneTransactionItem } from './utils.js';
+
 function getTxStatus(tx) {
   if (tx.action === "swap" && tx.transactionSpecificData.source === "metabase") return "success";
+  if (isStandaloneTransactionItem(tx) && tx.dropped) {
+    if (tx.replacementTx?.action === "cancel") return "cancelled";
+    return "reverted";
+  }
   return tx.receipt?.status || "pending";
 }
 

package/dist/transactions/status.js.map

@@ -1 +1 @@
-{"version":3,"file":"status.js","sources":["../../src/transactions/status.ts"],"sourcesContent":["import type { TransactionReceipt } from \"viem\";\nimport type { TransactionItem } from \"./types\";\n\nexport type TxStatus = TransactionReceipt[\"status\"] | \"pending\";\n\nexport function getTxStatus(tx: TransactionItem): TxStatus {\n  if (tx.action === \"swap\" && tx.transactionSpecificData.source === \"metabase\")\n    return \"success\";\n\n  return tx.receipt?.status || \"pending\";\n}\n"],"names":["getTxStatus","tx","action","transactionSpecificData","source","receipt","status"],"mappings":"AAKO,SAASA,YAAYC,EAAAA,EAA+B;AACzD,EAAA,IAAIA,GAAGC,MAAAA,KAAW,MAAA,IAAUD,GAAGE,uBAAAA,CAAwBC,MAAAA,KAAW,YAChE,OAAO,SAAA;AAET,EAAA,OAAOH,EAAAA,CAAGI,SAASC,MAAAA,IAAU,SAAA;AAC/B;;;;"}
+{"version":3,"file":"status.js","sources":["../../src/transactions/status.ts"],"sourcesContent":["import type { TransactionReceipt } from \"viem\";\nimport type { TransactionItem } from \"./types\";\nimport { isStandaloneTransactionItem } from \"./utils\";\n\nexport type TxStatus = TransactionReceipt[\"status\"] | \"pending\" | \"cancelled\";\n\nexport function getTxStatus(tx: TransactionItem): TxStatus {\n  if (tx.action === \"swap\" && tx.transactionSpecificData.source === \"metabase\")\n    return \"success\";\n\n  if (isStandaloneTransactionItem(tx) && tx.dropped) {\n    if (tx.replacementTx?.action === \"cancel\") return \"cancelled\";\n    return \"reverted\";\n  }\n\n  return tx.receipt?.status || \"pending\";\n}\n"],"names":["getTxStatus","tx","action","transactionSpecificData","source","isStandaloneTransactionItem","dropped","replacementTx","receipt","status"],"mappings":";;AAMO,SAASA,YAAYC,EAAAA,EAA+B;AACzD,EAAA,IAAIA,GAAGC,MAAAA,KAAW,MAAA,IAAUD,GAAGE,uBAAAA,CAAwBC,MAAAA,KAAW,YAChE,OAAO,SAAA;AAET,EAAA,IAAIC,2BAAAA,CAA4BJ,EAAE,CAAA,IAAKA,EAAAA,CAAGK,OAAAA,EAAS;AACjD,IAAA,IAAIL,EAAAA,CAAGM,aAAAA,EAAeL,MAAAA,KAAW,QAAA,EAAU,OAAO,WAAA;AAClD,IAAA,OAAO,UAAA;AAAA,EACT;AAEA,EAAA,OAAOD,EAAAA,CAAGO,SAASC,MAAAA,IAAU,SAAA;AAC/B;;;;"}