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

package/dist/transactions/state/effects/finalize.js.map

@@ -1 +1 @@
-{"version":3,"file":"finalize.js","names":["atomEffect","allPendingBatchTransactionItemsAtom","allPendingStandaloneTransactionItemsAtom","finalizeBatchTxAtom","finalizeStandaloneTxAtom","transactionLogger","accountAtom","addressAtom","isConnectorWithSafeAsyncAtomLoadableAtom","isGnosisSafeTx","isConnectorWithSafeProvider","hasRunStandaloneEffect","finalizeStandaloneTxsEffect","get","set","pendingStandaloneTxs","filter","tx","log","forEach","hasRunStandaloneSafeEffect","finalizeStandaloneSafeTxsEffect","connector","address","connectedSafe","loadableResult","state","data","getAccounts","getChainId","addressLower","toLowerCase","pendingSafeTxs","account","hasRunBatchEffect","finalizeBatchTxsEffect","pendingBatchTxs","hasRunBatchSafeEffect","finalizeBatchSafeTxsEffect","pendingSafeBatchTxs"],"sources":["../../../../src/transactions/state/effects/finalize.ts"],"sourcesContent":["import { atomEffect } from \"jotai-effect\";\nimport {\n  allPendingBatchTransactionItemsAtom,\n  allPendingStandaloneTransactionItemsAtom,\n} from \"../transactionsAtom\";\nimport {\n  finalizeBatchTxAtom,\n  finalizeStandaloneTxAtom,\n} from \"../transactionsActionAtom\";\n\nimport { transactionLogger } from \"../../logger\";\nimport {\n  accountAtom,\n  addressAtom,\n  isConnectorWithSafeAsyncAtomLoadableAtom,\n} from \"@/lib/web3/wagmi/external\";\nimport { isGnosisSafeTx } from \"@/transactions/utils\";\nimport { isConnectorWithSafeProvider } from \"@/components/web3/ConnectExternalProvider/utils\";\n\n// run only once on app load\nlet hasRunStandaloneEffect = false;\nexport const finalizeStandaloneTxsEffect = atomEffect((get, set) => {\n  if (hasRunStandaloneEffect) return;\n  hasRunStandaloneEffect = true;\n\n  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom)\n    // txs through safe are handled in another effect\n    .filter((tx) => !isGnosisSafeTx(tx));\n  transactionLogger.log(\"Effect::pendingStandaloneTxs\", pendingStandaloneTxs);\n  pendingStandaloneTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));\n});\n\n// waitForTransactionReceipt(connectorClient,{safeTxHash}) requires wallet to be connected through safe connector\nlet hasRunStandaloneSafeEffect = false;\nexport const finalizeStandaloneSafeTxsEffect = atomEffect((get, set) => {\n  if (hasRunStandaloneSafeEffect) return;\n  const { connector, address } = get(accountAtom);\n  let connectedSafe = connector && isConnectorWithSafeProvider(connector);\n\n  if (!connectedSafe) {\n    // loadable atom is required because atomEffect callback can't be async\n    const loadableResult = get(isConnectorWithSafeAsyncAtomLoadableAtom);\n    if (loadableResult.state === \"hasData\" && loadableResult.data) {\n      connectedSafe = true;\n    }\n  }\n\n  // try finalize when:\n  // - connected through safe connector\n  // - all required methods are available for ensureTxReceipt(){getConnectorClient()}\n  // otherwise it will throw ConnectorUnavailableReconnectingError\n  if (\n    connectedSafe &&\n    !!connector?.getAccounts &&\n    !!connector?.getChainId &&\n    address\n  ) {\n    hasRunStandaloneSafeEffect = true;\n\n    const addressLower = address.toLowerCase();\n\n    const pendingSafeTxs = get(allPendingStandaloneTransactionItemsAtom)\n      .filter(isGnosisSafeTx)\n      // only trigger Safe tx finalization if the same Safe that made the tx is connected\n      .filter((tx) => tx.account.toLowerCase() === addressLower);\n    transactionLogger.log(\"Effect::pendingSafeTxs\", pendingSafeTxs);\n    pendingSafeTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));\n  }\n});\n\n// run only once after account is connected and available in atom\n// because waitForCallsStatus requires wallet to be connected\nlet hasRunBatchEffect = false;\nexport const finalizeBatchTxsEffect = atomEffect((get, set) => {\n  if (hasRunBatchEffect) return;\n\n  const address = get(addressAtom);\n  if (address) {\n    hasRunBatchEffect = true;\n\n    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom)\n      // batch txs through safe are handled in another effect\n      .filter((tx) => !isGnosisSafeTx(tx));\n    transactionLogger.log(\"Effect::pendingBatchTxs\", pendingBatchTxs);\n    pendingBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));\n  }\n});\n\nlet hasRunBatchSafeEffect = false;\nexport const finalizeBatchSafeTxsEffect = atomEffect((get, set) => {\n  if (hasRunBatchSafeEffect) return;\n  const { connector, address } = get(accountAtom);\n\n  let connectedSafe = connector && isConnectorWithSafeProvider(connector);\n\n  if (!connectedSafe) {\n    // loadable atom is required because atomEffect callback can't be async\n    const loadableResult = get(isConnectorWithSafeAsyncAtomLoadableAtom);\n    if (loadableResult.state === \"hasData\" && loadableResult.data) {\n      connectedSafe = true;\n    }\n  }\n\n  // try finalize when:\n  // - connected through safe connector\n  // - all required methods are available for ensureCallsStatus(){getConnectorClient()}\n  // otherwise it will throw ConnectorUnavailableReconnectingError\n  if (\n    connectedSafe &&\n    !!connector?.getAccounts &&\n    !!connector?.getChainId &&\n    address\n  ) {\n    hasRunBatchSafeEffect = true;\n\n    const addressLower = address.toLowerCase();\n\n    const pendingSafeBatchTxs = get(allPendingBatchTransactionItemsAtom)\n      .filter(isGnosisSafeTx)\n      // only trigger Safe tx finalization if the same Safe that made the tx is connected\n      .filter((tx) => tx.account.toLowerCase() === addressLower);\n    transactionLogger.log(\"Effect::pendingSafeBatchTxs\", pendingSafeBatchTxs);\n    pendingSafeBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));\n  }\n});\n"],"mappings":";;;;;;;;AAoBA,IAAIW,IAAyB,IAChBC,IAA8BZ,GAAYa,GAAKC,MAAQ;AAClE,KAAIH,EAAwB;AAC5BA,KAAyB;CAEzB,IAAMI,IAAuBF,EAAIX,EAAwC,CAEtEc,QAAQC,MAAO,CAACR,EAAeQ,EAAG,CAAC;AAEtCF,CADAV,EAAkBa,IAAI,gCAAgCH,EAAqB,EAC3EA,EAAqBI,SAASF,MAAOH,EAAIV,GAA0Ba,EAAG,CAAC;EACvE,EAGEG,IAA6B,IACpBC,IAAkCrB,GAAYa,GAAKC,MAAQ;AACtE,KAAIM,EAA4B;CAChC,IAAM,EAAEE,cAAWC,eAAYV,EAAIP,EAAY,EAC3CkB,IAAgBF,KAAaZ,EAA4BY,EAAU;AAEvE,KAAI,CAACE,GAAe;EAElB,IAAMC,IAAiBZ,EAAIL,EAAyC;AACpE,EAAIiB,EAAeC,UAAU,aAAaD,EAAeE,SACvDH,IAAgB;;AAQpB,KACEA,KACEF,GAAWM,eACXN,GAAWO,cACbN,GACA;AACAH,MAA6B;EAE7B,IAAMU,IAAeP,EAAQQ,aAAa,EAEpCC,IAAiBnB,EAAIX,EAAyC,CACjEc,OAAOP,EAAc,CAErBO,QAAQC,MAAOA,EAAGgB,QAAQF,aAAa,KAAKD,EAAa;AAE5DE,EADA3B,EAAkBa,IAAI,0BAA0Bc,EAAe,EAC/DA,EAAeb,SAASF,MAAOH,EAAIV,GAA0Ba,EAAG,CAAC;;EAEnE,EAIEiB,IAAoB,IACXC,IAAyBnC,GAAYa,GAAKC,MAAQ;AACzDoB,WAEYrB,EAAIN,EAAY,EACnB;AACX2B,MAAoB;EAEpB,IAAME,IAAkBvB,EAAIZ,EAAmC,CAE5De,QAAQC,MAAO,CAACR,EAAeQ,EAAG,CAAC;AAEtCmB,EADA/B,EAAkBa,IAAI,2BAA2BkB,EAAgB,EACjEA,EAAgBjB,SAASF,MAAOH,EAAIX,GAAqBc,EAAG,CAAC;;EAE/D,EAEEoB,IAAwB,IACfC,IAA6BtC,GAAYa,GAAKC,MAAQ;AACjE,KAAIuB,EAAuB;CAC3B,IAAM,EAAEf,cAAWC,eAAYV,EAAIP,EAAY,EAE3CkB,IAAgBF,KAAaZ,EAA4BY,EAAU;AAEvE,KAAI,CAACE,GAAe;EAElB,IAAMC,IAAiBZ,EAAIL,EAAyC;AACpE,EAAIiB,EAAeC,UAAU,aAAaD,EAAeE,SACvDH,IAAgB;;AAQpB,KACEA,KACEF,GAAWM,eACXN,GAAWO,cACbN,GACA;AACAc,MAAwB;EAExB,IAAMP,IAAeP,EAAQQ,aAAa,EAEpCQ,IAAsB1B,EAAIZ,EAAoC,CACjEe,OAAOP,EAAc,CAErBO,QAAQC,MAAOA,EAAGgB,QAAQF,aAAa,KAAKD,EAAa;AAE5DS,EADAlC,EAAkBa,IAAI,+BAA+BqB,EAAoB,EACzEA,EAAoBpB,SAASF,MAAOH,EAAIX,GAAqBc,EAAG,CAAC;;EAEnE"}
+{"version":3,"file":"finalize.js","sources":["../../../../src/transactions/state/effects/finalize.ts"],"sourcesContent":["import { atomEffect } from \"jotai-effect\";\nimport {\n  allPendingBatchTransactionItemsAtom,\n  allPendingStandaloneTransactionItemsAtom,\n} from \"../transactionsAtom\";\nimport {\n  finalizeBatchTxAtom,\n  finalizeStandaloneTxAtom,\n} from \"../transactionsActionAtom\";\n\nimport { transactionLogger } from \"../../logger\";\nimport {\n  accountAtom,\n  addressAtom,\n  isConnectorWithSafeAsyncAtomLoadableAtom,\n} from \"@/lib/web3/wagmi/external\";\nimport { isGnosisSafeTx } from \"@/transactions/utils\";\nimport { isConnectorWithSafeProvider } from \"@/components/web3/ConnectExternalProvider/utils\";\n\n// run only once on app load\nlet hasRunStandaloneEffect = false;\nexport const finalizeStandaloneTxsEffect = atomEffect((get, set) => {\n  if (hasRunStandaloneEffect) return;\n  hasRunStandaloneEffect = true;\n\n  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom)\n    // txs through safe are handled in another effect\n    .filter((tx) => !isGnosisSafeTx(tx));\n  transactionLogger.log(\"Effect::pendingStandaloneTxs\", pendingStandaloneTxs);\n  pendingStandaloneTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));\n});\n\n// waitForTransactionReceipt(connectorClient,{safeTxHash}) requires wallet to be connected through safe connector\nlet hasRunStandaloneSafeEffect = false;\nexport const finalizeStandaloneSafeTxsEffect = atomEffect((get, set) => {\n  if (hasRunStandaloneSafeEffect) return;\n  const { connector, address } = get(accountAtom);\n  let connectedSafe = connector && isConnectorWithSafeProvider(connector);\n\n  if (!connectedSafe) {\n    // loadable atom is required because atomEffect callback can't be async\n    const loadableResult = get(isConnectorWithSafeAsyncAtomLoadableAtom);\n    if (loadableResult.state === \"hasData\" && loadableResult.data) {\n      connectedSafe = true;\n    }\n  }\n\n  // try finalize when:\n  // - connected through safe connector\n  // - all required methods are available for ensureTxReceipt(){getConnectorClient()}\n  // otherwise it will throw ConnectorUnavailableReconnectingError\n  if (\n    connectedSafe &&\n    !!connector?.getAccounts &&\n    !!connector?.getChainId &&\n    address\n  ) {\n    hasRunStandaloneSafeEffect = true;\n\n    const addressLower = address.toLowerCase();\n\n    const pendingSafeTxs = get(allPendingStandaloneTransactionItemsAtom)\n      .filter(isGnosisSafeTx)\n      // only trigger Safe tx finalization if the same Safe that made the tx is connected\n      .filter((tx) => tx.account.toLowerCase() === addressLower);\n    transactionLogger.log(\"Effect::pendingSafeTxs\", pendingSafeTxs);\n    pendingSafeTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));\n  }\n});\n\n// run only once after account is connected and available in atom\n// because waitForCallsStatus requires wallet to be connected\nlet hasRunBatchEffect = false;\nexport const finalizeBatchTxsEffect = atomEffect((get, set) => {\n  if (hasRunBatchEffect) return;\n\n  const address = get(addressAtom);\n  if (address) {\n    hasRunBatchEffect = true;\n\n    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom)\n      // batch txs through safe are handled in another effect\n      .filter((tx) => !isGnosisSafeTx(tx));\n    transactionLogger.log(\"Effect::pendingBatchTxs\", pendingBatchTxs);\n    pendingBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));\n  }\n});\n\nlet hasRunBatchSafeEffect = false;\nexport const finalizeBatchSafeTxsEffect = atomEffect((get, set) => {\n  if (hasRunBatchSafeEffect) return;\n  const { connector, address } = get(accountAtom);\n\n  let connectedSafe = connector && isConnectorWithSafeProvider(connector);\n\n  if (!connectedSafe) {\n    // loadable atom is required because atomEffect callback can't be async\n    const loadableResult = get(isConnectorWithSafeAsyncAtomLoadableAtom);\n    if (loadableResult.state === \"hasData\" && loadableResult.data) {\n      connectedSafe = true;\n    }\n  }\n\n  // try finalize when:\n  // - connected through safe connector\n  // - all required methods are available for ensureCallsStatus(){getConnectorClient()}\n  // otherwise it will throw ConnectorUnavailableReconnectingError\n  if (\n    connectedSafe &&\n    !!connector?.getAccounts &&\n    !!connector?.getChainId &&\n    address\n  ) {\n    hasRunBatchSafeEffect = true;\n\n    const addressLower = address.toLowerCase();\n\n    const pendingSafeBatchTxs = get(allPendingBatchTransactionItemsAtom)\n      .filter(isGnosisSafeTx)\n      // only trigger Safe tx finalization if the same Safe that made the tx is connected\n      .filter((tx) => tx.account.toLowerCase() === addressLower);\n    transactionLogger.log(\"Effect::pendingSafeBatchTxs\", pendingSafeBatchTxs);\n    pendingSafeBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));\n  }\n});\n"],"names":["hasRunStandaloneEffect","finalizeStandaloneTxsEffect","atomEffect","get","set","pendingStandaloneTxs","allPendingStandaloneTransactionItemsAtom","filter","tx","isGnosisSafeTx","transactionLogger","log","forEach","finalizeStandaloneTxAtom","hasRunStandaloneSafeEffect","finalizeStandaloneSafeTxsEffect","connector","address","accountAtom","connectedSafe","isConnectorWithSafeProvider","loadableResult","isConnectorWithSafeAsyncAtomLoadableAtom","state","data","getAccounts","getChainId","addressLower","toLowerCase","pendingSafeTxs","account","hasRunBatchEffect","finalizeBatchTxsEffect","addressAtom","pendingBatchTxs","allPendingBatchTransactionItemsAtom","finalizeBatchTxAtom","hasRunBatchSafeEffect","finalizeBatchSafeTxsEffect","pendingSafeBatchTxs"],"mappings":"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"}

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

@@ -1,10 +1,12 @@
-import { useAtom as e } from "../../../core/store.js";
-import { finalizeBatchSafeTxsEffect as t, finalizeBatchTxsEffect as n, finalizeStandaloneSafeTxsEffect as r, finalizeStandaloneTxsEffect as i } from "../effects/finalize.js";
-//#region src/transactions/state/hooks/useActivateEffects.ts
-function a() {
-	e(i), e(r), e(n), e(t);
+import { useAtom } from '../../../core/store.js';
+import { finalizeStandaloneTxsEffect, finalizeStandaloneSafeTxsEffect, finalizeBatchTxsEffect, finalizeBatchSafeTxsEffect } from '../effects/finalize.js';
+
+function useActivateEffects() {
+  useAtom(finalizeStandaloneTxsEffect);
+  useAtom(finalizeStandaloneSafeTxsEffect);
+  useAtom(finalizeBatchTxsEffect);
+  useAtom(finalizeBatchSafeTxsEffect);
 }
-//#endregion
-export { a as useActivateEffects };
 
-//# sourceMappingURL=useActivateEffects.js.map
+export { useActivateEffects };
+//# sourceMappingURL=useActivateEffects.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useActivateEffects.js","names":["useAtom","finalizeBatchTxsEffect","finalizeStandaloneTxsEffect","finalizeStandaloneSafeTxsEffect","finalizeBatchSafeTxsEffect","useActivateEffects"],"sources":["../../../../src/transactions/state/hooks/useActivateEffects.ts"],"sourcesContent":["import { useAtom } from \"@/core/store\";\nimport {\n  finalizeBatchTxsEffect,\n  finalizeStandaloneTxsEffect,\n  finalizeStandaloneSafeTxsEffect,\n  finalizeBatchSafeTxsEffect,\n} from \"@/transactions/state/effects/finalize\";\n\nexport function useActivateEffects() {\n  // atomEffects must be rendered for subscriptions to activate\n  useAtom(finalizeStandaloneTxsEffect);\n  useAtom(finalizeStandaloneSafeTxsEffect);\n  useAtom(finalizeBatchTxsEffect);\n  useAtom(finalizeBatchSafeTxsEffect);\n}\n"],"mappings":";;;AAQA,SAAOK,IAAA;AAKLL,CAHAA,EAAQE,EAA4B,EACpCF,EAAQG,EAAgC,EACxCH,EAAQC,EAAuB,EAC/BD,EAAQI,EAA2B"}
+{"version":3,"file":"useActivateEffects.js","sources":["../../../../src/transactions/state/hooks/useActivateEffects.ts"],"sourcesContent":["import { useAtom } from \"@/core/store\";\nimport {\n  finalizeBatchTxsEffect,\n  finalizeStandaloneTxsEffect,\n  finalizeStandaloneSafeTxsEffect,\n  finalizeBatchSafeTxsEffect,\n} from \"@/transactions/state/effects/finalize\";\n\nexport function useActivateEffects() {\n  // atomEffects must be rendered for subscriptions to activate\n  useAtom(finalizeStandaloneTxsEffect);\n  useAtom(finalizeStandaloneSafeTxsEffect);\n  useAtom(finalizeBatchTxsEffect);\n  useAtom(finalizeBatchSafeTxsEffect);\n}\n"],"names":["useActivateEffects","useAtom","finalizeStandaloneTxsEffect","finalizeStandaloneSafeTxsEffect","finalizeBatchTxsEffect","finalizeBatchSafeTxsEffect"],"mappings":";;;AAQO,SAAAA,kBAAAA,GAAA;AAELC,EAAAA,OAAAA,CAAQC,2BAA2B,CAAA;AACnCD,EAAAA,OAAAA,CAAQE,+BAA+B,CAAA;AACvCF,EAAAA,OAAAA,CAAQG,sBAAsB,CAAA;AAC9BH,EAAAA,OAAAA,CAAQI,0BAA0B,CAAA;AAAC;;;;"}

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

@@ -1,10 +1,10 @@
-import { useSetAtom as e } from "../../../core/store.js";
-import { markTxAsDroppedAtom as t } from "../transactionsActionAtom.js";
-//#region src/transactions/state/hooks/useMarkTxAsDropped.ts
-function n() {
-	return e(t);
+import { useSetAtom } from '../../../core/store.js';
+import { markTxAsDroppedAtom } from '../transactionsActionAtom.js';
+
+function useMarkTxAsDropped() {
+  const markTxAsDropped = useSetAtom(markTxAsDroppedAtom);
+  return markTxAsDropped;
 }
-//#endregion
-export { n as useMarkTxAsDropped };
 
-//# sourceMappingURL=useMarkTxAsDropped.js.map
+export { useMarkTxAsDropped };
+//# sourceMappingURL=useMarkTxAsDropped.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useMarkTxAsDropped.js","names":["useSetAtom","markTxAsDroppedAtom","useMarkTxAsDropped","markTxAsDropped"],"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"],"mappings":";;;AAGA,SAAOE,IAAA;AACmD,QAAhCF,EAAWC,EAAoB"}
+{"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/hooks/useTransactions.js

@@ -1,30 +1,70 @@
-import { useAtomValue as e } from "../../../core/store.js";
-import { useAllEnabledChains as t } from "../../../core/state/enabledChainsAtom.js";
-import { userPendingTransactionsAtom as n, userSwapTransactionsAtom as r } from "../transactionsAtom.js";
-import { c as i } from "react-compiler-runtime";
-//#region src/transactions/state/hooks/useTransactions.ts
-var a = () => e(n), o = () => e(r), s = () => {
-	let e = i(5), n = t(), r = o(), a;
-	if (e[0] !== n || e[1] !== r) {
-		let t;
-		e[3] === n ? t = e[4] : (t = (e) => {
-			let { chainId: t } = e;
-			return n.includes(t);
-		}, e[3] = n, e[4] = t), a = r.filter(t), e[0] = n, e[1] = r, e[2] = a;
-	} else a = e[2];
-	return a;
-}, c = () => {
-	let e = i(5), n = t(), r = a(), o;
-	if (e[0] !== n || e[1] !== r) {
-		let t;
-		e[3] === n ? t = e[4] : (t = (e) => {
-			let { chainId: t } = e;
-			return n.includes(t);
-		}, e[3] = n, e[4] = t), o = r.filter(t), e[0] = n, e[1] = r, e[2] = o;
-	} else o = e[2];
-	return o;
+import { d as distExports } from '../../../_virtual/index.js';
+import { useAtomValue } from '../../../core/store.js';
+import { userSwapTransactionsAtom, userPendingTransactionsAtom } from '../transactionsAtom.js';
+import { useAllEnabledChains } from '../../../core/state/enabledChainsAtom.js';
+
+const useUserPendingTransactions = () => {
+  return useAtomValue(userPendingTransactionsAtom);
+};
+const useUserSwapTransactions = () => {
+  return useAtomValue(userSwapTransactionsAtom);
+};
+const useUserSwapTransactionsOnEnabledChains = () => {
+  const $ = distExports.c(5);
+  const enabledChains = useAllEnabledChains();
+  const swapTransactions = useUserSwapTransactions();
+  let t0;
+  if ($[0] !== enabledChains || $[1] !== swapTransactions) {
+    let t1;
+    if ($[3] !== enabledChains) {
+      t1 = (t2) => {
+        const {
+          chainId
+        } = t2;
+        return enabledChains.includes(chainId);
+      };
+      $[3] = enabledChains;
+      $[4] = t1;
+    } else {
+      t1 = $[4];
+    }
+    t0 = swapTransactions.filter(t1);
+    $[0] = enabledChains;
+    $[1] = swapTransactions;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
+};
+const useUserPendingTransactionsOnEnabledChains = () => {
+  const $ = distExports.c(5);
+  const enabledChains = useAllEnabledChains();
+  const pendingTransactions = useUserPendingTransactions();
+  let t0;
+  if ($[0] !== enabledChains || $[1] !== pendingTransactions) {
+    let t1;
+    if ($[3] !== enabledChains) {
+      t1 = (t2) => {
+        const {
+          chainId
+        } = t2;
+        return enabledChains.includes(chainId);
+      };
+      $[3] = enabledChains;
+      $[4] = t1;
+    } else {
+      t1 = $[4];
+    }
+    t0 = pendingTransactions.filter(t1);
+    $[0] = enabledChains;
+    $[1] = pendingTransactions;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  return t0;
 };
-//#endregion
-export { c as useUserPendingTransactionsOnEnabledChains, s as useUserSwapTransactionsOnEnabledChains };
 
-//# sourceMappingURL=useTransactions.js.map
+export { useUserPendingTransactions, useUserPendingTransactionsOnEnabledChains, useUserSwapTransactions, useUserSwapTransactionsOnEnabledChains };
+//# sourceMappingURL=useTransactions.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"useTransactions.js","names":["useAtomValue","userPendingTransactionsAtom","userSwapTransactionsAtom","useAllEnabledChains","useUserPendingTransactions","useUserSwapTransactions","useUserSwapTransactionsOnEnabledChains","$","_c","enabledChains","swapTransactions","t0","t1","t2","chainId","includes","filter","useUserPendingTransactionsOnEnabledChains","pendingTransactions"],"sources":["../../../../src/transactions/state/hooks/useTransactions.ts"],"sourcesContent":["import { useAtomValue } from \"@/core/store\";\nimport {\n  userPendingTransactionsAtom,\n  userSwapTransactionsAtom,\n} from \"../transactionsAtom\";\nimport { useAllEnabledChains } from \"@/core/state/enabledChainsAtom\";\n\nexport const useUserPendingTransactions = () =>\n  useAtomValue(userPendingTransactionsAtom);\nexport const useUserSwapTransactions = () =>\n  useAtomValue(userSwapTransactionsAtom);\n\nexport const useUserSwapTransactionsOnEnabledChains = () => {\n  const enabledChains = useAllEnabledChains();\n  const swapTransactions = useUserSwapTransactions();\n  return swapTransactions.filter(({ chainId }) =>\n    enabledChains.includes(chainId)\n  );\n};\nexport const useUserPendingTransactionsOnEnabledChains = () => {\n  const enabledChains = useAllEnabledChains();\n  const pendingTransactions = useUserPendingTransactions();\n  return pendingTransactions.filter(({ chainId }) =>\n    enabledChains.includes(chainId)\n  );\n};\n"],"mappings":";;;;;AAOA,IAAaI,UACXJ,EAAaC,EAA4B,EAC9BI,UACXL,EAAaE,EAAyB,EAE3BI,UAAyC;CAAA,IAAAC,IAAAC,EAAA,EAAA,EACpDC,IAAsBN,GAAqB,EAC3CO,IAAyBL,GAAyB,EAACM;AAAA,KAAAJ,EAAA,OAAAE,KAAAF,EAAA,OAAAG,GAAA;EAAA,IAAAE;AAGlDL,EAHkDA,EAAA,OAAAE,IAElBG,IAAAL,EAAA,MADFK,KAAAC,MAAA;GAAC,IAAA,EAAAC,eAAAD;AAAW,UACzCJ,EAAaM,SAAUD,EAAQ;KAAAP,EAAA,KAAAE,GAAAF,EAAA,KAAAK,IAD1BD,IAAAD,EAAgBM,OAAQJ,EAE9B,EAAAL,EAAA,KAAAE,GAAAF,EAAA,KAAAG,GAAAH,EAAA,KAAAI;OAAAA,KAAAJ,EAAA;AAAA,QAFMI;GAIIM,UAA4C;CAAA,IAAAV,IAAAC,EAAA,EAAA,EACvDC,IAAsBN,GAAqB,EAC3Ce,IAA4Bd,GAA4B,EAACO;AAAA,KAAAJ,EAAA,OAAAE,KAAAF,EAAA,OAAAW,GAAA;EAAA,IAAAN;AAGxDL,EAHwDA,EAAA,OAAAE,IAExBG,IAAAL,EAAA,MADCK,KAAAC,MAAA;GAAC,IAAA,EAAAC,eAAAD;AAAW,UAC5CJ,EAAaM,SAAUD,EAAQ;KAAAP,EAAA,KAAAE,GAAAF,EAAA,KAAAK,IAD1BD,IAAAO,EAAmBF,OAAQJ,EAEjC,EAAAL,EAAA,KAAAE,GAAAF,EAAA,KAAAW,GAAAX,EAAA,KAAAI;OAAAA,KAAAJ,EAAA;AAAA,QAFMI"}
+{"version":3,"file":"useTransactions.js","sources":["../../../../src/transactions/state/hooks/useTransactions.ts"],"sourcesContent":["import { useAtomValue } from \"@/core/store\";\nimport {\n  userPendingTransactionsAtom,\n  userSwapTransactionsAtom,\n} from \"../transactionsAtom\";\nimport { useAllEnabledChains } from \"@/core/state/enabledChainsAtom\";\n\nexport const useUserPendingTransactions = () =>\n  useAtomValue(userPendingTransactionsAtom);\nexport const useUserSwapTransactions = () =>\n  useAtomValue(userSwapTransactionsAtom);\n\nexport const useUserSwapTransactionsOnEnabledChains = () => {\n  const enabledChains = useAllEnabledChains();\n  const swapTransactions = useUserSwapTransactions();\n  return swapTransactions.filter(({ chainId }) =>\n    enabledChains.includes(chainId)\n  );\n};\nexport const useUserPendingTransactionsOnEnabledChains = () => {\n  const enabledChains = useAllEnabledChains();\n  const pendingTransactions = useUserPendingTransactions();\n  return pendingTransactions.filter(({ chainId }) =>\n    enabledChains.includes(chainId)\n  );\n};\n"],"names":["useUserPendingTransactions","useAtomValue","userPendingTransactionsAtom","useUserSwapTransactions","userSwapTransactionsAtom","useUserSwapTransactionsOnEnabledChains","$","_c","enabledChains","useAllEnabledChains","swapTransactions","t0","t1","t2","chainId","includes","filter","useUserPendingTransactionsOnEnabledChains","pendingTransactions"],"mappings":";;;;;AAOO,MAAMA,6BAA6BA,MAAA;AAAA,EAAA,OACxCC,aAAaC,2BAA2B,CAAA;AAAC;AACpC,MAAMC,0BAA0BA,MAAA;AAAA,EAAA,OACrCF,aAAaG,wBAAwB,CAAA;AAAC;AAEjC,MAAMC,yCAAyCA,MAAA;AAAA,EAAA,MAAAC,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACpD,EAAA,MAAAC,gBAAsBC,mBAAAA,EAAoB;AAC1C,EAAA,MAAAC,mBAAyBP,uBAAAA,EAAwB;AAAE,EAAA,IAAAQ,EAAAA;AAAA,EAAA,IAAAL,EAAA,CAAA,CAAA,KAAAE,iBAAAF,CAAAA,QAAAI,gBAAAA,EAAA;AAAA,IAAA,IAAAE,EAAAA;AAAA,IAAA,IAAAN,CAAAA,QAAAE,aAAAA,EAAA;AACpBI,MAAAA,EAAAA,GAAAC,CAAAA,EAAAA,KAAA;AAAC,QAAA,MAAA;AAAA,UAAAC;AAAAA,SAAA,GAAAD,EAAAA;AAAW,QAAA,OACzCL,aAAAA,CAAaO,SAAUD,OAAO,CAAA;AAAA,MAAC,CAAA;AAAAR,MAAAA,CAAAA,MAAAE,aAAAA;AAAAF,MAAAA,CAAAA,MAAAM,EAAAA;AAAAA,IAAA,CAAA,MAAA;AAAAA,MAAAA,EAAAA,GAAAN,EAAA,CAAA,CAAA;AAAA,IAAA;AAD1BK,IAAAA,EAAAA,GAAAD,gBAAAA,CAAgBM,OAAQJ,EAE/B,CAAA;AAACN,IAAAA,CAAAA,MAAAE,aAAAA;AAAAF,IAAAA,CAAAA,MAAAI,gBAAAA;AAAAJ,IAAAA,CAAAA,MAAAK,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAL,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAFMK,EAAAA;AAEN;AAEI,MAAMM,4CAA4CA,MAAA;AAAA,EAAA,MAAAX,CAAAA,GAAAC,cAAA,CAAA,CAAA;AACvD,EAAA,MAAAC,gBAAsBC,mBAAAA,EAAoB;AAC1C,EAAA,MAAAS,sBAA4BlB,0BAAAA,EAA2B;AAAE,EAAA,IAAAW,EAAAA;AAAA,EAAA,IAAAL,EAAA,CAAA,CAAA,KAAAE,iBAAAF,CAAAA,QAAAY,mBAAAA,EAAA;AAAA,IAAA,IAAAN,EAAAA;AAAA,IAAA,IAAAN,CAAAA,QAAAE,aAAAA,EAAA;AACvBI,MAAAA,EAAAA,GAAAC,CAAAA,EAAAA,KAAA;AAAC,QAAA,MAAA;AAAA,UAAAC;AAAAA,SAAA,GAAAD,EAAAA;AAAW,QAAA,OAC5CL,aAAAA,CAAaO,SAAUD,OAAO,CAAA;AAAA,MAAC,CAAA;AAAAR,MAAAA,CAAAA,MAAAE,aAAAA;AAAAF,MAAAA,CAAAA,MAAAM,EAAAA;AAAAA,IAAA,CAAA,MAAA;AAAAA,MAAAA,EAAAA,GAAAN,EAAA,CAAA,CAAA;AAAA,IAAA;AAD1BK,IAAAA,EAAAA,GAAAO,mBAAAA,CAAmBF,OAAQJ,EAElC,CAAA;AAACN,IAAAA,CAAAA,MAAAE,aAAAA;AAAAF,IAAAA,CAAAA,MAAAY,mBAAAA;AAAAZ,IAAAA,CAAAA,MAAAK,EAAAA;AAAAA,EAAA,CAAA,MAAA;AAAAA,IAAAA,EAAAA,GAAAL,EAAA,CAAA,CAAA;AAAA,EAAA;AAAA,EAAA,OAFMK,EAAAA;AAEN;;;;"}

package/dist/transactions/state/transactionsActionAtom.js

@@ -1,151 +1,226 @@
-import { jotaiStore as e } from "../../core/store.js";
-import { isConnectorWithSafeProvider as t } from "../../components/web3/ConnectExternalProvider/utils.js";
-import { isBatchTransactionItem as n, isGnosisSafeTx as r, isStandaloneTransactionItem as i } from "../utils.js";
-import { accountAtom as a, isConnectorWithSafeAsyncAtomLoadableAtom as o } from "../../lib/web3/wagmi/external.js";
-import { transactionsAtom as s } from "./transactionsAtom.js";
-import { ensureCallsStatusFactory as c } from "../queries/ensureCallsStatus.js";
-import { ensureTxReceiptFactory as l } from "../queries/ensureTxReceipt.js";
-import { transactionLogger as u } from "../logger.js";
-import { atom as d } from "jotai";
-import { assert as f } from "ts-essentials";
-import { CallExecutionError as p, MethodNotSupportedRpcError as m, TransactionReceiptNotFoundError as h, WaitForCallsStatusTimeoutError as g, WaitForTransactionReceiptTimeoutError as _ } from "viem";
-//#region src/transactions/state/transactionsActionAtom.ts
-var v = d(null, (e, n, r) => {
-	let { connector: c, address: l } = e(a);
-	f(c && l, "connector and address are required");
-	let u = t(c);
-	if (!u) {
-		let t = e(o);
-		t.state === "hasData" && t.data && (u = !0);
-	}
-	let d = {
-		...r,
-		account: l,
-		timestamp: Date.now(),
-		dropped: !1,
-		connectorData: {
-			type: c.type,
-			id: c.id,
-			isSafe: u
-		}
-	};
-	n(s, (e) => w(e, d)), i(d) ? n(y, d) : n(b, d);
-}), y = d(null, async (e, t, n) => {
-	let i = { ...n }, a = l(), o = r(i);
-	try {
-		i.receipt = await a({
-			hash: i.transactionHash,
-			chainId: i.chainId
-		});
-	} catch (e) {
-		if (e instanceof _ || e instanceof h || e instanceof p) i.dropped = !0, u.error("tx dropped", {
-			error: e,
-			finalizedTx: i,
-			isTxThroughSafe: o
-		});
-		else throw e;
-	} finally {
-		(i.receipt || i.dropped) && (t(s, (e) => w(e, i)), u.log("tx finalized", {
-			finalizedTx: i,
-			isTxThroughSafe: o
-		}));
-	}
-}), b = d(null, async (e, t, n) => {
-	let r = { ...n }, i = c();
-	try {
-		let { receipts: e, status: t } = await i({ id: r.callsId });
-		r.callsStatus = t, r.receipt = e?.[e.length - 1];
-	} catch (e) {
-		if (e instanceof g || e instanceof m) r.dropped = !0, u.error("batch tx dropped", {
-			error: e,
-			finalizedTx: r
-		});
-		else throw r.callsStatus = "failure", u.error("batch tx failed", {
-			error: e,
-			finalizedTx: r
-		}), e;
-	} finally {
-		t(s, (e) => w(e, r)), u.log("batch tx finalized", { finalizedTx: r });
-	}
-}), x = async (t) => e.set(v, t), S = d(null, (e, t, n) => {
-	let { txHash: r, action: a, replacementTxHash: o, account: c } = n;
-	t(s, (e) => {
-		let t = e[c] || {}, n = r, s = t[n];
-		if (!s || !i(s)) return e;
-		let l = {
-			...s,
-			dropped: !0
-		};
-		a && o && (l.replacementTx = {
-			hash: o,
-			action: a
-		});
-		let u = {
-			...t,
-			[n]: l
-		};
-		return {
-			...e,
-			[c]: u
-		};
-	});
+import { atom } from 'jotai';
+import { jotaiStore } from '../../core/store.js';
+import { ensureCallsStatusFactory } from '../queries/ensureCallsStatus.js';
+import { ensureTxReceiptFactory } from '../queries/ensureTxReceipt.js';
+import { WaitForTransactionReceiptTimeoutError, TransactionReceiptNotFoundError, CallExecutionError, WaitForCallsStatusTimeoutError, MethodNotSupportedRpcError } from 'viem';
+import { transactionLogger } from '../logger.js';
+import { transactionsAtom } from './transactionsAtom.js';
+import { isGnosisSafeTx, isStandaloneTransactionItem, isBatchTransactionItem } from '../utils.js';
+import { assert } from 'ts-essentials';
+import { accountAtom, isConnectorWithSafeAsyncAtomLoadableAtom } from '../../lib/web3/wagmi/external.js';
+import { isConnectorWithSafeProvider } from '../../components/web3/ConnectExternalProvider/utils.js';
+
+const addTxAtom = atom(null, (get, set, transaction) => {
+  const {
+    connector,
+    address
+  } = get(accountAtom);
+  assert(connector && address, "connector and address are required");
+  let isSafe = isConnectorWithSafeProvider(connector);
+  if (!isSafe) {
+    const loadableResult = get(isConnectorWithSafeAsyncAtomLoadableAtom);
+    if (loadableResult.state === "hasData" && loadableResult.data) {
+      isSafe = true;
+    }
+  }
+  const txWithMeta = {
+    ...transaction,
+    account: address,
+    timestamp: Date.now(),
+    dropped: false,
+    connectorData: {
+      type: connector.type,
+      id: connector.id,
+      isSafe
+    }
+  };
+  set(transactionsAtom, (current) => assignTx(current, txWithMeta));
+  if (isStandaloneTransactionItem(txWithMeta)) {
+    set(finalizeStandaloneTxAtom, txWithMeta);
+  } else {
+    set(finalizeBatchTxAtom, txWithMeta);
+  }
+});
+const finalizeStandaloneTxAtom = atom(null, async (_, set, transaction) => {
+  const finalizedTx = {
+    ...transaction
+  };
+  const ensureTxReceipt = ensureTxReceiptFactory();
+  const isTxThroughSafe = isGnosisSafeTx(finalizedTx);
+  try {
+    const txReceipt = await ensureTxReceipt({
+      hash: finalizedTx.transactionHash,
+      chainId: finalizedTx.chainId
+    });
+    finalizedTx.receipt = txReceipt;
+  } catch (error) {
+    if (
+      /* 
+        At different steps of the waitForTransactionReceipt func different errors can be thrown.
+        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),
+        we can even get a useless Error("unknown reason") or Error("0xrandom_hash")
+      */
+      error instanceof WaitForTransactionReceiptTimeoutError || // thrown when transaction is not found within the timeout period
+      error instanceof TransactionReceiptNotFoundError || // thrown when transaction receipt is not found
+      error instanceof CallExecutionError
+    ) {
+      finalizedTx.dropped = true;
+      transactionLogger.error("tx dropped", {
+        error,
+        finalizedTx,
+        isTxThroughSafe
+      });
+    } else throw error;
+  } finally {
+    if (finalizedTx.receipt || finalizedTx.dropped) {
+      set(transactionsAtom, (current) => assignTx(current, finalizedTx));
+      transactionLogger.log("tx finalized", {
+        finalizedTx,
+        isTxThroughSafe
+      });
+    }
+  }
+});
+const finalizeBatchTxAtom = atom(null, async (_, set, transaction) => {
+  const finalizedTx = {
+    ...transaction
+  };
+  const ensureCallsStatus = ensureCallsStatusFactory();
+  try {
+    const {
+      receipts,
+      status
+    } = await ensureCallsStatus({
+      id: finalizedTx.callsId
+    });
+    finalizedTx.callsStatus = status;
+    finalizedTx.receipt = receipts?.[receipts.length - 1];
+  } catch (error) {
+    if (error instanceof WaitForCallsStatusTimeoutError || error instanceof MethodNotSupportedRpcError) {
+      finalizedTx.dropped = true;
+      transactionLogger.error("batch tx dropped", {
+        error,
+        finalizedTx
+      });
+    } else {
+      finalizedTx.callsStatus = "failure";
+      transactionLogger.error("batch tx failed", {
+        error,
+        finalizedTx
+      });
+      throw error;
+    }
+  } finally {
+    set(transactionsAtom, (current) => assignTx(current, finalizedTx));
+    transactionLogger.log("batch tx finalized", {
+      finalizedTx
+    });
+  }
+});
+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 C(e) {
-	if (n(e)) {
-		let t = {
-			action: e.action,
-			account: e.account,
-			chainId: e.chainId,
-			callsId: e.callsId,
-			callsStatus: e.callsStatus,
-			timestamp: e.timestamp,
-			dropped: e.dropped,
-			receipt: e.receipt,
-			transactionSpecificData: e.transactionSpecificData
-		};
-		return e.connectorData && (t.connectorData = {
-			type: e.connectorData.type,
-			id: e.connectorData.id,
-			isSafe: e.connectorData.isSafe ?? r(e)
-		}), t;
-	}
-	let t = {
-		action: e.action,
-		chainId: e.chainId,
-		account: e.account,
-		transactionHash: e.transactionHash,
-		timestamp: e.timestamp,
-		dropped: e.dropped,
-		receipt: e.receipt,
-		transactionSpecificData: e.transactionSpecificData
-	};
-	return e.connectorData && (t.connectorData = {
-		type: e.connectorData.type,
-		id: e.connectorData.id,
-		isSafe: e.connectorData.isSafe ?? r(e)
-	}), e.replacementTx && (t.replacementTx = {
-		hash: e.replacementTx.hash,
-		action: e.replacementTx.action
-	}), t;
+function sanitizeTx(tx) {
+  if (isBatchTransactionItem(tx)) {
+    const txItem2 = {
+      action: tx.action,
+      account: tx.account,
+      chainId: tx.chainId,
+      callsId: tx.callsId,
+      callsStatus: tx.callsStatus,
+      timestamp: tx.timestamp,
+      dropped: tx.dropped,
+      receipt: tx.receipt,
+      transactionSpecificData: tx.transactionSpecificData
+    };
+    if (tx.connectorData) {
+      txItem2.connectorData = {
+        type: tx.connectorData.type,
+        id: tx.connectorData.id,
+        // extra check for backwards compatibility with txs from localStorage without connectorData.isSafe
+        isSafe: tx.connectorData.isSafe ?? isGnosisSafeTx(tx)
+      };
+    }
+    return txItem2;
+  }
+  const txItem = {
+    action: tx.action,
+    chainId: tx.chainId,
+    account: tx.account,
+    transactionHash: tx.transactionHash,
+    timestamp: tx.timestamp,
+    dropped: tx.dropped,
+    receipt: tx.receipt,
+    transactionSpecificData: tx.transactionSpecificData
+  };
+  if (tx.connectorData) {
+    txItem.connectorData = {
+      type: tx.connectorData.type,
+      id: tx.connectorData.id,
+      // extra check for backwards compatibility with txs from localStorage without connectorData.isSafe
+      isSafe: tx.connectorData.isSafe ?? isGnosisSafeTx(tx)
+    };
+  }
+  if (tx.replacementTx) {
+    txItem.replacementTx = {
+      hash: tx.replacementTx.hash,
+      action: tx.replacementTx.action
+    };
+  }
+  return txItem;
 }
-function w(e, t) {
-	u.log("assignTx", {
-		account: t.account,
-		transaction: t
-	});
-	let n = e[t.account] || {}, r = i(t) ? t.transactionHash : t.callsId, a = {
-		...n,
-		[r]: C({
-			...n[r],
-			...t
-		})
-	};
-	return {
-		...e,
-		[t.account]: a
-	};
+function assignTx(currentTransactions, transaction) {
+  transactionLogger.log("assignTx", {
+    account: transaction.account,
+    transaction
+  });
+  const accountTransactions = currentTransactions[transaction.account] || {};
+  const identifier = isStandaloneTransactionItem(transaction) ? transaction.transactionHash : transaction.callsId;
+  const updatedAccountTransactions = {
+    ...accountTransactions,
+    [identifier]: sanitizeTx({
+      ...accountTransactions[identifier],
+      ...transaction
+    })
+  };
+  return {
+    ...currentTransactions,
+    [transaction.account]: updatedAccountTransactions
+  };
 }
-//#endregion
-export { x as addTx, b as finalizeBatchTxAtom, y as finalizeStandaloneTxAtom, S as markTxAsDroppedAtom };
 
-//# sourceMappingURL=transactionsActionAtom.js.map
+export { addTx, addTxAtom, finalizeBatchTxAtom, finalizeStandaloneTxAtom, markTxAsDroppedAtom };
+//# sourceMappingURL=transactionsActionAtom.js.map