@velora-dex/widget 0.3.11-dev.8 → 0.3.12

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

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

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

@@ -1,7 +1,6 @@
 import * as wagmi from '@wagmi/core';
 import { wagmiConfig } from './config.js';
 import { isSafeConnector } from '../../../hooks/connectors/useIsGnosisSafeConnector.js';
-import { isExternalConnectorSafeIframe } from '../../../components/web3/ConnectExternalProvider/utils.js';
 
 async function switchChain({
   chainId
@@ -10,10 +9,7 @@ async function switchChain({
     connector,
     isConnected
   } = wagmi.getAccount(wagmiConfig);
-  let isSafe = connector && isSafeConnector(connector);
-  if (!isSafe && connector && isExternalConnectorSafeIframe(connector)) {
-    isSafe = true;
-  }
+  const isSafe = connector && isSafeConnector(connector);
   if (isConnected) wagmiConfig.setState((prev) => ({
     ...prev,
     chainId

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

@@ -1 +1 @@
-{"version":3,"file":"switchChain.js","sources":["../../../../src/lib/web3/wagmi/switchChain.ts"],"sourcesContent":["import * as wagmi from \"@wagmi/core\";\nimport { wagmiConfig } from \"./config\";\nimport type { SupportedChainId } from \"./types\";\nimport { isSafeConnector } from \"@/hooks/connectors/useIsGnosisSafeConnector\";\nimport { isExternalConnectorSafeIframe } from \"@/components/web3/ConnectExternalProvider/utils\";\n\nexport async function switchChain({ chainId }: { chainId: SupportedChainId }) {\n  const { connector, isConnected } = wagmi.getAccount(wagmiConfig);\n  let isSafe = connector && isSafeConnector(connector);\n\n  // check if external provider is supplied and it's a Safe iframe provider\n  if (!isSafe && connector && isExternalConnectorSafeIframe(connector)) {\n    isSafe = true;\n  }\n\n  // wagmi doesn't autoswitch state chainId with syncConnectedChain=false if connected\n  if (isConnected) wagmiConfig.setState((prev) => ({ ...prev, chainId }));\n\n  // safe doesn't support programmatic chain switching\n  if (!isSafe) return wagmi.switchChain(wagmiConfig, { chainId });\n}\n"],"names":["switchChain","chainId","connector","isConnected","wagmi","getAccount","wagmiConfig","isSafe","isSafeConnector","isExternalConnectorSafeIframe","setState","prev"],"mappings":";;;;;AAMA,eAAsBA,WAAAA,CAAY;AAAA,EAAEC;AAAuC,CAAA,EAAG;AAC5E,EAAA,MAAM;AAAA,IAAEC,SAAAA;AAAAA,IAAWC;AAAAA,GAAY,GAAIC,KAAAA,CAAMC,UAAAA,CAAWC,WAAW,CAAA;AAC/D,EAAA,IAAIC,MAAAA,GAASL,SAAAA,IAAaM,eAAAA,CAAgBN,SAAS,CAAA;AAGnD,EAAA,IAAI,CAACK,MAAAA,IAAUL,SAAAA,IAAaO,6BAAAA,CAA8BP,SAAS,CAAA,EAAG;AACpEK,IAAAA,MAAAA,GAAS,IAAA;AAAA,EACX;AAGA,EAAA,IAAIJ,WAAAA,EAAaG,WAAAA,CAAYI,QAAAA,CAAUC,CAAAA,IAAAA,MAAU;AAAA,IAAE,GAAGA,IAAAA;AAAAA,IAAMV;AAAAA,GAAQ,CAAE,CAAA;AAGtE,EAAA,IAAI,CAACM,MAAAA,EAAQ,OAAOH,KAAAA,CAAMJ,YAAYM,WAAAA,EAAa;AAAA,IAAEL;AAAAA,GAAS,CAAA;AAChE;;;;"}
+{"version":3,"file":"switchChain.js","sources":["../../../../src/lib/web3/wagmi/switchChain.ts"],"sourcesContent":["import * as wagmi from \"@wagmi/core\";\nimport { wagmiConfig } from \"./config\";\nimport type { SupportedChainId } from \"./types\";\nimport { isSafeConnector } from \"@/hooks/connectors/useIsGnosisSafeConnector\";\n\nexport async function switchChain({ chainId }: { chainId: SupportedChainId }) {\n  const { connector, isConnected } = wagmi.getAccount(wagmiConfig);\n  const isSafe = connector && isSafeConnector(connector);\n\n  // wagmi doesn't autoswitch state chainId with syncConnectedChain=false if connected\n  if (isConnected) wagmiConfig.setState((prev) => ({ ...prev, chainId }));\n\n  // safe doesn't support programmatic chain switching\n  if (!isSafe) return wagmi.switchChain(wagmiConfig, { chainId });\n}\n"],"names":["switchChain","chainId","connector","isConnected","wagmi","getAccount","wagmiConfig","isSafe","isSafeConnector","setState","prev"],"mappings":";;;;AAKA,eAAsBA,WAAAA,CAAY;AAAA,EAAEC;AAAuC,CAAA,EAAG;AAC5E,EAAA,MAAM;AAAA,IAAEC,SAAAA;AAAAA,IAAWC;AAAAA,GAAY,GAAIC,KAAAA,CAAMC,UAAAA,CAAWC,WAAW,CAAA;AAC/D,EAAA,MAAMC,MAAAA,GAASL,SAAAA,IAAaM,eAAAA,CAAgBN,SAAS,CAAA;AAGrD,EAAA,IAAIC,WAAAA,EAAaG,WAAAA,CAAYG,QAAAA,CAAUC,CAAAA,IAAAA,MAAU;AAAA,IAAE,GAAGA,IAAAA;AAAAA,IAAMT;AAAAA,GAAQ,CAAE,CAAA;AAGtE,EAAA,IAAI,CAACM,MAAAA,EAAQ,OAAOH,KAAAA,CAAMJ,YAAYM,WAAAA,EAAa;AAAA,IAAEL;AAAAA,GAAS,CAAA;AAChE;;;;"}

package/dist/styles.css

@@ -70,7 +70,7 @@
     }
   }
 }
-.velora-widget {
+:root, :host {
   --font-sans: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
   --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
   --color-red-800: oklch(44.4% .177 26.899);

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

@@ -1 +1 @@
-{"version":3,"file":"ensureCallsStatus.d.ts","sourceRoot":"","sources":["../../../src/transactions/queries/ensureCallsStatus.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAkC,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1E,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE;IAC1C,EAAE,EAAE,MAAM,CAAC;CACZ,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAEtC,KAAK,wBAAwB,GAAG,CAAC,MAAM,CAAC,EAAE;IACxC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,KAAK,mBAAmB,CAAC;AAE1B,eAAO,MAAM,wBAAwB,EAAE,wBAiCpC,CAAC"}
+{"version":3,"file":"ensureCallsStatus.d.ts","sourceRoot":"","sources":["../../../src/transactions/queries/ensureCallsStatus.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAsB,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE9D,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,aAAa,CAAC;AAErB,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE;IAC1C,EAAE,EAAE,MAAM,CAAC;CACZ,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;AAEtC,KAAK,wBAAwB,GAAG,CAAC,MAAM,CAAC,EAAE;IACxC,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,KAAK,mBAAmB,CAAC;AAE1B,eAAO,MAAM,wBAAwB,EAAE,wBAwBpC,CAAC"}

package/dist/transactions/queries/ensureCallsStatus.js

@@ -1,29 +1,21 @@
-import { isExternalConnectorSafeIframe } from '../../components/web3/ConnectExternalProvider/utils.js';
-import { isSafeConnector } from '../../hooks/connectors/useIsGnosisSafeConnector.js';
 import { SAFE_CALLS_WAIT_TIMEOUT } from '../../lib/constants/index.js';
 import { queryClient } from '../../lib/queryClient.js';
 import { wagmiConfig } from '../../lib/web3/wagmi/config.js';
-import { getAccount, waitForCallsStatus } from '@wagmi/core';
+import { waitForCallsStatus } from '@wagmi/core';
 import { waitForCallsStatusQueryKey } from 'wagmi/query';
 
 const ensureCallsStatusFactory = ({
   queryClient: queryClient$1 = queryClient,
   wagmiConfig: wagmiConfig$1 = wagmiConfig,
-  isSafe: _isSafe
+  isSafe = false
 } = {}) => async ({
   id
 }) => {
-  const {
-    connector
-  } = getAccount(wagmiConfig$1);
-  const isConnectedToSafeIframe = !!connector && (isSafeConnector(connector) || isExternalConnectorSafeIframe(connector));
-  const isSafe = _isSafe || isConnectedToSafeIframe;
   const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : void 0;
   const queryKey = waitForCallsStatusQueryKey({
     id,
-    timeout,
+    timeout
     // important to include timeout into queryKey to match useAwaitCalls queryKey
-    throwOnFailure: true
   });
   const status = await queryClient$1.ensureQueryData({
     queryKey,

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

@@ -1 +1 @@
-{"version":3,"file":"ensureCallsStatus.js","sources":["../../../src/transactions/queries/ensureCallsStatus.ts"],"sourcesContent":["import { isExternalConnectorSafeIframe } from \"@/components/web3/ConnectExternalProvider/utils\";\nimport { isSafeConnector } from \"@/hooks/connectors/useIsGnosisSafeConnector\";\nimport { SAFE_CALLS_WAIT_TIMEOUT } from \"@/lib/constants\";\nimport { queryClient as _queryClient } from \"@/lib/queryClient\";\nimport { wagmiConfig as _wagmiConfig } from \"@/lib/web3/wagmi/config\";\nimport type { QueryClient } from \"@tanstack/react-query\";\nimport { getAccount, waitForCallsStatus, type Config } from \"@wagmi/core\";\n\nimport {\n  waitForCallsStatusQueryKey,\n  type WaitForCallsStatusData,\n} from \"wagmi/query\";\n\nexport type EnsureCallsStatusFn = (options: {\n  id: string;\n}) => Promise<WaitForCallsStatusData>;\n\ntype EnsureCallsStatusFactory = (params?: {\n  queryClient?: QueryClient;\n  wagmiConfig?: Config;\n  isSafe?: boolean;\n}) => EnsureCallsStatusFn;\n\nexport const ensureCallsStatusFactory: EnsureCallsStatusFactory =\n  ({\n    queryClient = _queryClient,\n    wagmiConfig = _wagmiConfig,\n    isSafe: _isSafe,\n  } = {}) =>\n  async ({ id }) => {\n    const { connector } = getAccount(wagmiConfig);\n    const isConnectedToSafeIframe =\n      !!connector &&\n      (isSafeConnector(connector) || isExternalConnectorSafeIframe(connector));\n\n    const isSafe = _isSafe || isConnectedToSafeIframe;\n\n    const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : undefined;\n\n    const queryKey = waitForCallsStatusQueryKey({\n      id,\n      timeout, // important to include timeout into queryKey to match useAwaitCalls queryKey\n      throwOnFailure: true,\n    });\n    const status = await queryClient.ensureQueryData({\n      queryKey,\n      queryFn: async () => {\n        return waitForCallsStatus(wagmiConfig, {\n          id,\n          throwOnFailure: true,\n          timeout,\n        });\n      },\n    });\n\n    return status;\n  };\n"],"names":["ensureCallsStatusFactory","queryClient","_queryClient","wagmiConfig","_wagmiConfig","isSafe","_isSafe","id","connector","getAccount","isConnectedToSafeIframe","isSafeConnector","isExternalConnectorSafeIframe","timeout","SAFE_CALLS_WAIT_TIMEOUT","undefined","queryKey","waitForCallsStatusQueryKey","throwOnFailure","status","ensureQueryData","queryFn","waitForCallsStatus"],"mappings":";;;;;;;;AAuBO,MAAMA,2BACXA,CAAC;AAAA,eACCC,aAAAA,GAAcC,WAAAA;AAAAA,eACdC,aAAAA,GAAcC,WAAAA;AAAAA,EACdC,MAAAA,EAAQC;AACV,CAAA,GAAI,OACJ,OAAO;AAAA,EAAEC;AAAG,CAAA,KAAM;AAChB,EAAA,MAAM;AAAA,IAAEC;AAAAA,GAAU,GAAIC,WAAWN,aAAW,CAAA;AAC5C,EAAA,MAAMO,uBAAAA,GACJ,CAAC,CAACF,SAAAA,KACDG,gBAAgBH,SAAS,CAAA,IAAKI,8BAA8BJ,SAAS,CAAA,CAAA;AAExE,EAAA,MAAMH,SAASC,OAAAA,IAAWI,uBAAAA;AAE1B,EAAA,MAAMG,OAAAA,GAAUR,SAASS,uBAAAA,GAA0BC,MAAAA;AAEnD,EAAA,MAAMC,WAAWC,0BAAAA,CAA2B;AAAA,IAC1CV,EAAAA;AAAAA,IACAM,OAAAA;AAAAA;AAAAA,IACAK,cAAAA,EAAgB;AAAA,GACjB,CAAA;AACD,EAAA,MAAMC,MAAAA,GAAS,MAAMlB,aAAAA,CAAYmB,eAAAA,CAAgB;AAAA,IAC/CJ,QAAAA;AAAAA,IACAK,SAAS,YAAY;AACnB,MAAA,OAAOC,mBAAmBnB,aAAAA,EAAa;AAAA,QACrCI,EAAAA;AAAAA,QACAW,cAAAA,EAAgB,IAAA;AAAA,QAChBL;AAAAA,OACD,CAAA;AAAA,IACH;AAAA,GACD,CAAA;AAED,EAAA,OAAOM,MAAAA;AACT;;;;"}
+{"version":3,"file":"ensureCallsStatus.js","sources":["../../../src/transactions/queries/ensureCallsStatus.ts"],"sourcesContent":["import { SAFE_CALLS_WAIT_TIMEOUT } from \"@/lib/constants\";\nimport { queryClient as _queryClient } from \"@/lib/queryClient\";\nimport { wagmiConfig as _wagmiConfig } from \"@/lib/web3/wagmi/config\";\nimport type { QueryClient } from \"@tanstack/react-query\";\nimport { waitForCallsStatus, type Config } from \"@wagmi/core\";\n\nimport {\n  waitForCallsStatusQueryKey,\n  type WaitForCallsStatusData,\n} from \"wagmi/query\";\n\nexport type EnsureCallsStatusFn = (options: {\n  id: string;\n}) => Promise<WaitForCallsStatusData>;\n\ntype EnsureCallsStatusFactory = (params?: {\n  queryClient?: QueryClient;\n  wagmiConfig?: Config;\n  isSafe?: boolean;\n}) => EnsureCallsStatusFn;\n\nexport const ensureCallsStatusFactory: EnsureCallsStatusFactory =\n  ({\n    queryClient = _queryClient,\n    wagmiConfig = _wagmiConfig,\n    isSafe = false,\n  } = {}) =>\n  async ({ id }) => {\n    const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : undefined;\n    const queryKey = waitForCallsStatusQueryKey({\n      id,\n      timeout, // important to include timeout into queryKey to match useAwaitCalls queryKey\n    });\n    const status = await queryClient.ensureQueryData({\n      queryKey,\n      queryFn: async () => {\n        return waitForCallsStatus(wagmiConfig, {\n          id,\n          throwOnFailure: true,\n          timeout,\n        });\n      },\n    });\n\n    return status;\n  };\n"],"names":["ensureCallsStatusFactory","queryClient","_queryClient","wagmiConfig","_wagmiConfig","isSafe","id","timeout","SAFE_CALLS_WAIT_TIMEOUT","undefined","queryKey","waitForCallsStatusQueryKey","status","ensureQueryData","queryFn","waitForCallsStatus","throwOnFailure"],"mappings":";;;;;;AAqBO,MAAMA,2BACXA,CAAC;AAAA,eACCC,aAAAA,GAAcC,WAAAA;AAAAA,eACdC,aAAAA,GAAcC,WAAAA;AAAAA,EACdC,MAAAA,GAAS;AACX,CAAA,GAAI,OACJ,OAAO;AAAA,EAAEC;AAAG,CAAA,KAAM;AAChB,EAAA,MAAMC,OAAAA,GAAUF,SAASG,uBAAAA,GAA0BC,MAAAA;AACnD,EAAA,MAAMC,WAAWC,0BAAAA,CAA2B;AAAA,IAC1CL,EAAAA;AAAAA,IACAC;AAAAA;AAAAA,GACD,CAAA;AACD,EAAA,MAAMK,MAAAA,GAAS,MAAMX,aAAAA,CAAYY,eAAAA,CAAgB;AAAA,IAC/CH,QAAAA;AAAAA,IACAI,SAAS,YAAY;AACnB,MAAA,OAAOC,mBAAmBZ,aAAAA,EAAa;AAAA,QACrCG,EAAAA;AAAAA,QACAU,cAAAA,EAAgB,IAAA;AAAA,QAChBT;AAAAA,OACD,CAAA;AAAA,IACH;AAAA,GACD,CAAA;AAED,EAAA,OAAOK,MAAAA;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;AAK1C,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;AAExB,eAAO,MAAM,sBAAsB,EAAE,sBA+ClC,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;AAI1C,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;AAExB,eAAO,MAAM,sBAAsB,EAAE,sBAsClC,CAAC"}

package/dist/transactions/queries/ensureTxReceipt.js

@@ -7,26 +7,23 @@ import { SAFE_CALLS_WAIT_TIMEOUT } from '../../lib/constants/index.js';
 import 'wagmi/chains';
 import { getAccount, getConnectorClient } from '@wagmi/core';
 import { isSafeConnector } from '../../hooks/connectors/useIsGnosisSafeConnector.js';
-import { isExternalConnectorSafeIframe } from '../../components/web3/ConnectExternalProvider/utils.js';
 
 const ensureTxReceiptFactory = ({
   queryClient: queryClient$1 = queryClient,
   wagmiConfig: wagmiConfig$1 = wagmiConfig,
-  isSafe: _isSafe
+  isSafe
 } = {}) => async ({
   hash,
   chainId,
   confirmations,
   onReplaced
 }) => {
+  const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : void 0;
+  let config = wagmiConfig$1;
   const {
     connector
   } = getAccount(wagmiConfig$1);
-  const isConnectedToSafeIframe = !!connector && (isSafeConnector(connector) || isExternalConnectorSafeIframe(connector));
-  const isSafe = _isSafe || isConnectedToSafeIframe;
-  const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : void 0;
-  let config = wagmiConfig$1;
-  if (isConnectedToSafeIframe) {
+  if (connector && isSafeConnector(connector)) {
     const safeClient = await getConnectorClient(wagmiConfig$1, {
       chainId,
       connector

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 { isSafeConnector } from \"@/hooks/connectors/useIsGnosisSafeConnector\";\nimport { isExternalConnectorSafeIframe } from \"@/components/web3/ConnectExternalProvider/utils\";\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\nexport const ensureTxReceiptFactory: EnsureTxReceiptFactory =\n  ({\n    queryClient = _queryClient,\n    wagmiConfig = _wagmiConfig,\n    isSafe: _isSafe,\n  } = {}) =>\n  async ({ hash, chainId, confirmations, onReplaced }) => {\n    const { connector } = getAccount(wagmiConfig);\n    const isConnectedToSafeIframe =\n      !!connector &&\n      (isSafeConnector(connector) || isExternalConnectorSafeIframe(connector));\n    const isSafe = _isSafe || isConnectedToSafeIframe;\n\n    const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : undefined;\n\n    let config = wagmiConfig;\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      // force waitForTransactionReceiptQueryOptions to use SafeClient internally\n      config = {\n        ...wagmiConfig,\n        getClient: (options) => {\n          assert(!options || options.chainId === chainId, \"chainId mismatch\");\n          return safeClient;\n        },\n      } as typeof wagmiConfig;\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,\n      chainId,\n      confirmations,\n      timeout,\n      onReplaced,\n    });\n\n    const receipt = await queryClient.ensureQueryData(queryOptions);\n\n    return receipt;\n  };\n"],"names":["ensureTxReceiptFactory","queryClient","_queryClient","wagmiConfig","_wagmiConfig","isSafe","_isSafe","hash","chainId","confirmations","onReplaced","connector","getAccount","isConnectedToSafeIframe","isSafeConnector","isExternalConnectorSafeIframe","timeout","SAFE_CALLS_WAIT_TIMEOUT","undefined","config","safeClient","getConnectorClient","getClient","options","assert","queryOptions","waitForTransactionReceiptQueryOptions","receipt","ensureQueryData"],"mappings":";;;;;;;;;;;AAgCO,MAAMA,yBACXA,CAAC;AAAA,eACCC,aAAAA,GAAcC,WAAAA;AAAAA,eACdC,aAAAA,GAAcC,WAAAA;AAAAA,EACdC,MAAAA,EAAQC;AACV,CAAA,GAAI,OACJ,OAAO;AAAA,EAAEC,IAAAA;AAAAA,EAAMC,OAAAA;AAAAA,EAASC,aAAAA;AAAAA,EAAeC;AAAW,CAAA,KAAM;AACtD,EAAA,MAAM;AAAA,IAAEC;AAAAA,GAAU,GAAIC,WAAWT,aAAW,CAAA;AAC5C,EAAA,MAAMU,uBAAAA,GACJ,CAAC,CAACF,SAAAA,KACDG,gBAAgBH,SAAS,CAAA,IAAKI,8BAA8BJ,SAAS,CAAA,CAAA;AACxE,EAAA,MAAMN,SAASC,OAAAA,IAAWO,uBAAAA;AAE1B,EAAA,MAAMG,OAAAA,GAAUX,SAASY,uBAAAA,GAA0BC,MAAAA;AAEnD,EAAA,IAAIC,MAAAA,GAAShB,aAAAA;AAIb,EAAA,IAAIU,uBAAAA,EAAyB;AAC3B,IAAA,MAAMO,UAAAA,GAAa,MAAMC,kBAAAA,CAAmBlB,aAAAA,EAAa;AAAA,MACvDK,OAAAA;AAAAA,MACAG;AAAAA,KACD,CAAA;AAEDQ,IAAAA,MAAAA,GAAS;AAAA,MACP,GAAGhB,aAAAA;AAAAA,MACHmB,WAAYC,CAAAA,OAAAA,KAAY;AACtBC,QAAAA,MAAAA,CAAO,CAACD,OAAAA,IAAWA,OAAAA,CAAQf,OAAAA,KAAYA,SAAS,kBAAkB,CAAA;AAClE,QAAA,OAAOY,UAAAA;AAAAA,MACT;AAAA,KACF;AAAA,EACF;AAIA,EAAA,MAAMK,YAAAA,GAAeC,sCAAsCP,MAAAA,EAAQ;AAAA,IACjEZ,IAAAA;AAAAA,IACAC,OAAAA;AAAAA,IACAC,aAAAA;AAAAA,IACAO,OAAAA;AAAAA,IACAN;AAAAA,GACD,CAAA;AAED,EAAA,MAAMiB,OAAAA,GAAU,MAAM1B,aAAAA,CAAY2B,eAAAA,CAAgBH,YAAY,CAAA;AAE9D,EAAA,OAAOE,OAAAA;AACT;;;;"}
+{"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 { isSafeConnector } from \"@/hooks/connectors/useIsGnosisSafeConnector\";\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\nexport const ensureTxReceiptFactory: EnsureTxReceiptFactory =\n  ({ queryClient = _queryClient, wagmiConfig = _wagmiConfig, isSafe } = {}) =>\n  async ({ hash, chainId, confirmations, onReplaced }) => {\n    const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : undefined;\n\n    let config = wagmiConfig;\n    const { connector } = getAccount(wagmiConfig);\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 (connector && isSafeConnector(connector)) {\n      const safeClient = await getConnectorClient(wagmiConfig, {\n        chainId,\n        connector,\n      });\n      // force waitForTransactionReceiptQueryOptions to use SafeClient internally\n      config = {\n        ...wagmiConfig,\n        getClient: (options) => {\n          assert(!options || options.chainId === chainId, \"chainId mismatch\");\n          return safeClient;\n        },\n      } as typeof wagmiConfig;\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,\n      chainId,\n      confirmations,\n      timeout,\n      onReplaced,\n    });\n\n    const receipt = await queryClient.ensureQueryData(queryOptions);\n\n    return receipt;\n  };\n"],"names":["ensureTxReceiptFactory","queryClient","_queryClient","wagmiConfig","_wagmiConfig","isSafe","hash","chainId","confirmations","onReplaced","timeout","SAFE_CALLS_WAIT_TIMEOUT","undefined","config","connector","getAccount","isSafeConnector","safeClient","getConnectorClient","getClient","options","assert","queryOptions","waitForTransactionReceiptQueryOptions","receipt","ensureQueryData"],"mappings":";;;;;;;;;;AA+BO,MAAMA,yBACXA,CAAC;AAAA,eAAEC,aAAAA,GAAcC,WAAAA;AAAAA,eAAcC,aAAAA,GAAcC,WAAAA;AAAAA,EAAcC;AAAO,CAAA,GAAI,OACtE,OAAO;AAAA,EAAEC,IAAAA;AAAAA,EAAMC,OAAAA;AAAAA,EAASC,aAAAA;AAAAA,EAAeC;AAAW,CAAA,KAAM;AACtD,EAAA,MAAMC,OAAAA,GAAUL,SAASM,uBAAAA,GAA0BC,MAAAA;AAEnD,EAAA,IAAIC,MAAAA,GAASV,aAAAA;AACb,EAAA,MAAM;AAAA,IAAEW;AAAAA,GAAU,GAAIC,WAAWZ,aAAW,CAAA;AAI5C,EAAA,IAAIW,SAAAA,IAAaE,eAAAA,CAAgBF,SAAS,CAAA,EAAG;AAC3C,IAAA,MAAMG,UAAAA,GAAa,MAAMC,kBAAAA,CAAmBf,aAAAA,EAAa;AAAA,MACvDI,OAAAA;AAAAA,MACAO;AAAAA,KACD,CAAA;AAEDD,IAAAA,MAAAA,GAAS;AAAA,MACP,GAAGV,aAAAA;AAAAA,MACHgB,WAAYC,CAAAA,OAAAA,KAAY;AACtBC,QAAAA,MAAAA,CAAO,CAACD,OAAAA,IAAWA,OAAAA,CAAQb,OAAAA,KAAYA,SAAS,kBAAkB,CAAA;AAClE,QAAA,OAAOU,UAAAA;AAAAA,MACT;AAAA,KACF;AAAA,EACF;AAIA,EAAA,MAAMK,YAAAA,GAAeC,sCAAsCV,MAAAA,EAAQ;AAAA,IACjEP,IAAAA;AAAAA,IACAC,OAAAA;AAAAA,IACAC,aAAAA;AAAAA,IACAE,OAAAA;AAAAA,IACAD;AAAAA,GACD,CAAA;AAED,EAAA,MAAMe,OAAAA,GAAU,MAAMvB,aAAAA,CAAYwB,eAAAA,CAAgBH,YAAY,CAAA;AAE9D,EAAA,OAAOE,OAAAA;AACT;;;;"}

package/dist/transactions/state/effects/finalize.d.ts

@@ -1,13 +1,7 @@
-export declare const finalizeStandaloneTxsEffect: import('jotai').Atom<void> & {
-    effect: import('jotai-effect').Effect;
-};
-export declare const finalizeStandaloneSafeTxsEffect: import('jotai').Atom<void> & {
+export declare const finalizeStandoloneTxsEffect: import('jotai').Atom<void> & {
     effect: import('jotai-effect').Effect;
 };
 export declare const finalizeBatchTxsEffect: import('jotai').Atom<void> & {
     effect: import('jotai-effect').Effect;
 };
-export declare const finalizeBatchSafeTxsEffect: import('jotai').Atom<void> & {
-    effect: import('jotai-effect').Effect;
-};
 //# sourceMappingURL=finalize.d.ts.map

package/dist/transactions/state/effects/finalize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../../../../src/transactions/state/effects/finalize.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,2BAA2B;;CAStC,CAAC;AAIH,eAAO,MAAM,+BAA+B;;CA0B1C,CAAC;AAKH,eAAO,MAAM,sBAAsB;;CAajC,CAAC;AAGH,eAAO,MAAM,0BAA0B;;CA0BrC,CAAC"}
+{"version":3,"file":"finalize.d.ts","sourceRoot":"","sources":["../../../../src/transactions/state/effects/finalize.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,2BAA2B;;CAOtC,CAAC;AAKH,eAAO,MAAM,sBAAsB;;CAWjC,CAAC"}

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

@@ -2,61 +2,27 @@ import { atomEffect } from 'jotai-effect';
 import { allPendingStandaloneTransactionItemsAtom, allPendingBatchTransactionItemsAtom } from '../transactionsAtom.js';
 import { finalizeStandaloneTxAtom, finalizeBatchTxAtom } from '../transactionsActionAtom.js';
 import { transactionLogger } from '../../logger.js';
-import { accountAtom, addressAtom } from '../../../lib/web3/wagmi/external.js';
-import { isSafeConnector } from '../../../hooks/connectors/useIsGnosisSafeConnector.js';
-import { isGnosisSafeTx } from '../../utils.js';
+import { accountAtom } from '../../../lib/web3/wagmi/external.js';
 
 let hasRunStandaloneEffect = false;
-const finalizeStandaloneTxsEffect = atomEffect((get, set) => {
+const finalizeStandoloneTxsEffect = atomEffect((get, set) => {
   if (hasRunStandaloneEffect) return;
   hasRunStandaloneEffect = true;
-  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom).filter((tx) => !isGnosisSafeTx(tx));
+  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom);
   transactionLogger.log("Effect::pendingStandaloneTxs", pendingStandaloneTxs);
   pendingStandaloneTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));
 });
-let hasRunStandaloneSafeEffect = false;
-const finalizeStandaloneSafeTxsEffect = atomEffect((get, set) => {
-  if (hasRunStandaloneSafeEffect) return;
-  const {
-    connector,
-    address
-  } = get(accountAtom);
-  const connectedSafe = connector && isSafeConnector(connector);
-  if (connectedSafe && !!connector.getAccounts && !!connector.getChainId && address) {
-    hasRunStandaloneSafeEffect = true;
-    const addressLower = address.toLowerCase();
-    const pendingSafeTxs = get(allPendingStandaloneTransactionItemsAtom).filter(isGnosisSafeTx).filter((tx) => tx.account.toLowerCase() === addressLower);
-    transactionLogger.log("Effect::pendingSafeTxs", pendingSafeTxs);
-    pendingSafeTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));
-  }
-});
 let hasRunBatchEffect = false;
 const finalizeBatchTxsEffect = atomEffect((get, set) => {
   if (hasRunBatchEffect) return;
-  const address = get(addressAtom);
-  if (address) {
+  const account = get(accountAtom);
+  if (account) {
     hasRunBatchEffect = true;
-    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom).filter((tx) => !isGnosisSafeTx(tx));
+    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom);
     transactionLogger.log("Effect::pendingBatchTxs", pendingBatchTxs);
     pendingBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));
   }
 });
-let hasRunBatchSafeEffect = false;
-const finalizeBatchSafeTxsEffect = atomEffect((get, set) => {
-  if (hasRunBatchSafeEffect) return;
-  const {
-    connector,
-    address
-  } = get(accountAtom);
-  const connectedSafe = connector && isSafeConnector(connector);
-  if (connectedSafe && !!connector.getAccounts && !!connector.getChainId && address) {
-    hasRunBatchSafeEffect = true;
-    const addressLower = address.toLowerCase();
-    const pendingSafeBatchTxs = get(allPendingBatchTransactionItemsAtom).filter(isGnosisSafeTx).filter((tx) => tx.account.toLowerCase() === addressLower);
-    transactionLogger.log("Effect::pendingSafeBatchTxs", pendingSafeBatchTxs);
-    pendingSafeBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));
-  }
-});
 
-export { finalizeBatchSafeTxsEffect, finalizeBatchTxsEffect, finalizeStandaloneSafeTxsEffect, finalizeStandaloneTxsEffect };
+export { finalizeBatchTxsEffect, finalizeStandoloneTxsEffect };
 //# sourceMappingURL=finalize.js.map

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

@@ -1 +1 @@
-{"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 { accountAtom, addressAtom } from \"@/lib/web3/wagmi/external\";\nimport { isSafeConnector } from \"@/hooks/connectors/useIsGnosisSafeConnector\";\nimport { isGnosisSafeTx } from \"@/transactions/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  const connectedSafe = connector && isSafeConnector(connector);\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  const connectedSafe = connector && isSafeConnector(connector);\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","isSafeConnector","getAccounts","getChainId","addressLower","toLowerCase","pendingSafeTxs","account","hasRunBatchEffect","finalizeBatchTxsEffect","addressAtom","pendingBatchTxs","allPendingBatchTransactionItemsAtom","finalizeBatchTxAtom","hasRunBatchSafeEffect","finalizeBatchSafeTxsEffect","pendingSafeBatchTxs"],"mappings":"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"}
+{"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 { accountAtom } from \"@/lib/web3/wagmi/external\";\n\n// run only once on app load\nlet hasRunStandaloneEffect = false;\nexport const finalizeStandoloneTxsEffect = atomEffect((get, set) => {\n  if (hasRunStandaloneEffect) return;\n  hasRunStandaloneEffect = true;\n\n  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom);\n  transactionLogger.log(\"Effect::pendingStandaloneTxs\", pendingStandaloneTxs);\n  pendingStandaloneTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));\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 account = get(accountAtom);\n  if (account) {\n    hasRunBatchEffect = true;\n\n    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom);\n    transactionLogger.log(\"Effect::pendingBatchTxs\", pendingBatchTxs);\n    pendingBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));\n  }\n});\n"],"names":["hasRunStandaloneEffect","finalizeStandoloneTxsEffect","atomEffect","get","set","pendingStandaloneTxs","allPendingStandaloneTransactionItemsAtom","transactionLogger","log","forEach","tx","finalizeStandaloneTxAtom","hasRunBatchEffect","finalizeBatchTxsEffect","account","accountAtom","pendingBatchTxs","allPendingBatchTransactionItemsAtom","finalizeBatchTxAtom"],"mappings":";;;;;;AAcA,IAAIA,sBAAAA,GAAyB,KAAA;AACtB,MAAMC,2BAAAA,GAA8BC,UAAAA,CAAW,CAACC,GAAAA,EAAKC,GAAAA,KAAQ;AAClE,EAAA,IAAIJ,sBAAAA,EAAwB;AAC5BA,EAAAA,sBAAAA,GAAyB,IAAA;AAEzB,EAAA,MAAMK,oBAAAA,GAAuBF,IAAIG,wCAAwC,CAAA;AACzEC,EAAAA,iBAAAA,CAAkBC,GAAAA,CAAI,gCAAgCH,oBAAoB,CAAA;AAC1EA,EAAAA,oBAAAA,CAAqBI,OAAAA,CAASC,CAAAA,EAAAA,KAAON,GAAAA,CAAIO,wBAAAA,EAA0BD,EAAE,CAAC,CAAA;AACxE,CAAC;AAID,IAAIE,iBAAAA,GAAoB,KAAA;AACjB,MAAMC,sBAAAA,GAAyBX,UAAAA,CAAW,CAACC,GAAAA,EAAKC,GAAAA,KAAQ;AAC7D,EAAA,IAAIQ,iBAAAA,EAAmB;AAEvB,EAAA,MAAME,OAAAA,GAAUX,IAAIY,WAAW,CAAA;AAC/B,EAAA,IAAID,OAAAA,EAAS;AACXF,IAAAA,iBAAAA,GAAoB,IAAA;AAEpB,IAAA,MAAMI,eAAAA,GAAkBb,IAAIc,mCAAmC,CAAA;AAC/DV,IAAAA,iBAAAA,CAAkBC,GAAAA,CAAI,2BAA2BQ,eAAe,CAAA;AAChEA,IAAAA,eAAAA,CAAgBP,OAAAA,CAASC,CAAAA,EAAAA,KAAON,GAAAA,CAAIc,mBAAAA,EAAqBR,EAAE,CAAC,CAAA;AAAA,EAC9D;AACF,CAAC;;;;"}

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

@@ -1 +1 @@
-{"version":3,"file":"useActivateEffects.d.ts","sourceRoot":"","sources":["../../../../src/transactions/state/hooks/useActivateEffects.ts"],"names":[],"mappings":"AAQA,wBAAgB,kBAAkB,SAMjC"}
+{"version":3,"file":"useActivateEffects.d.ts","sourceRoot":"","sources":["../../../../src/transactions/state/hooks/useActivateEffects.ts"],"names":[],"mappings":"AAMA,wBAAgB,kBAAkB,SAIjC"}

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

@@ -1,11 +1,9 @@
 import { useAtom } from '../../../core/store.js';
-import { finalizeStandaloneTxsEffect, finalizeStandaloneSafeTxsEffect, finalizeBatchTxsEffect, finalizeBatchSafeTxsEffect } from '../effects/finalize.js';
+import { finalizeStandoloneTxsEffect, finalizeBatchTxsEffect } from '../effects/finalize.js';
 
 function useActivateEffects() {
-  useAtom(finalizeStandaloneTxsEffect);
-  useAtom(finalizeStandaloneSafeTxsEffect);
+  useAtom(finalizeStandoloneTxsEffect);
   useAtom(finalizeBatchTxsEffect);
-  useAtom(finalizeBatchSafeTxsEffect);
 }
 
 export { useActivateEffects };

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

@@ -1 +1 @@
-{"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;;;;"}
+{"version":3,"file":"useActivateEffects.js","sources":["../../../../src/transactions/state/hooks/useActivateEffects.ts"],"sourcesContent":["import { useAtom } from \"@/core/store\";\nimport {\n  finalizeBatchTxsEffect,\n  finalizeStandoloneTxsEffect,\n} from \"@/transactions/state/effects/finalize\";\n\nexport function useActivateEffects() {\n  // atomEffects must be rendered for subscriptions to activate\n  useAtom(finalizeStandoloneTxsEffect);\n  useAtom(finalizeBatchTxsEffect);\n}\n"],"names":["useActivateEffects","useAtom","finalizeStandoloneTxsEffect","finalizeBatchTxsEffect"],"mappings":";;;AAMO,SAAAA,kBAAAA,GAAA;AAELC,EAAAA,OAAAA,CAAQC,2BAA2B,CAAA;AACnCD,EAAAA,OAAAA,CAAQE,sBAAsB,CAAA;AAAC;;;;"}

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;AA2BlB,eAAO,MAAM,SAAS;;CAwBrB,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;AAuBlB,eAAO,MAAM,SAAS;;CAoBrB,CAAC;AAEF,eAAO,MAAM,wBAAwB;;CAgCnC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;CA8B9B,CAAC;AAEH,eAAO,MAAM,KAAK,GAAU,aAAa,kBAAkB,kBAE1D,CAAC"}

package/dist/transactions/state/transactionsActionAtom.js

@@ -5,25 +5,18 @@ 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 { isStandaloneTransactionItem, isBatchTransactionItem } from '../utils.js';
 import { accountAtom } from '../../lib/web3/wagmi/external.js';
+import { assert } from 'ts-essentials';
 
 const addTxAtom = atom(null, async (get, set, transaction) => {
-  const {
-    connector,
-    address
-  } = get(accountAtom);
-  assert(connector && address, "connector and address are required");
+  const account = get(accountAtom);
+  assert(account, "addTxAtom: account is required");
   const txWithMeta = {
     ...transaction,
-    account: address,
+    account,
     timestamp: Date.now(),
-    dropped: false,
-    connectorData: {
-      type: connector.type,
-      id: connector.id
-    }
+    dropped: false
   };
   set(transactionsAtom, (current) => assignTx(current, txWithMeta));
   if (isStandaloneTransactionItem(txWithMeta)) {
@@ -37,13 +30,11 @@ const finalizeStandaloneTxAtom = atom(null, async (_, set, transaction) => {
     ...transaction
   };
   const ensureTxReceipt = ensureTxReceiptFactory();
-  const isTxThroughSafe = isGnosisSafeTx(finalizedTx);
   try {
-    const txReceipt = await ensureTxReceipt({
-      hash: finalizedTx.transactionHash,
-      chainId: finalizedTx.chainId
+    finalizedTx.receipt = await ensureTxReceipt({
+      hash: transaction.transactionHash,
+      chainId: transaction.chainId
     });
-    finalizedTx.receipt = txReceipt;
   } catch (error) {
     if (
       /* 
@@ -56,20 +47,10 @@ const finalizeStandaloneTxAtom = atom(null, async (_, set, transaction) => {
       error instanceof CallExecutionError
     ) {
       finalizedTx.dropped = true;
-      transactionLogger.error("tx dropped", {
-        error,
-        finalizedTx,
-        isTxThroughSafe
-      });
+      transactionLogger.error(`finalizeStandaloneTxAtom::Transaction ${transaction.transactionHash} dropped with error: ${error.message}`);
     } else throw error;
   } finally {
-    if (finalizedTx.receipt || finalizedTx.dropped) {
-      set(transactionsAtom, (current) => assignTx(current, finalizedTx));
-      transactionLogger.log("tx finalized", {
-        finalizedTx,
-        isTxThroughSafe
-      });
-    }
+    set(transactionsAtom, (current) => assignTx(current, finalizedTx));
   }
 });
 const finalizeBatchTxAtom = atom(null, async (_, set, transaction) => {
@@ -82,30 +63,20 @@ const finalizeBatchTxAtom = atom(null, async (_, set, transaction) => {
       receipts,
       status
     } = await ensureCallsStatus({
-      id: finalizedTx.callsId
+      id: transaction.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
-      });
+      transactionLogger.error(`finalizeBatchTxAtom::Batch transaction ${transaction.callsId} dropped with error: ${error.message}`);
     } 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) => {
@@ -113,7 +84,7 @@ const addTx = async (transaction) => {
 };
 function sanitizeTx(tx) {
   if (isBatchTransactionItem(tx)) {
-    const txItem2 = {
+    return {
       action: tx.action,
       account: tx.account,
       chainId: tx.chainId,
@@ -124,15 +95,8 @@ function sanitizeTx(tx) {
       receipt: tx.receipt,
       transactionSpecificData: tx.transactionSpecificData
     };
-    if (tx.connectorData) {
-      txItem2.connectorData = {
-        type: tx.connectorData.type,
-        id: tx.connectorData.id
-      };
-    }
-    return txItem2;
   }
-  const txItem = {
+  return {
     action: tx.action,
     chainId: tx.chainId,
     account: tx.account,
@@ -142,13 +106,6 @@ function sanitizeTx(tx) {
     receipt: tx.receipt,
     transactionSpecificData: tx.transactionSpecificData
   };
-  if (tx.connectorData) {
-    txItem.connectorData = {
-      type: tx.connectorData.type,
-      id: tx.connectorData.id
-    };
-  }
-  return txItem;
 }
 function assignTx(currentTransactions, transaction) {
   transactionLogger.log("assignTx", {

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 { accountAtom } from \"@/lib/web3/wagmi/external\";\n\nexport const addTxAtom = atom<null, [transaction: MinTransactionItem], void>(\n  null,\n  async (get, set, transaction) => {\n    const { connector, address } = get(accountAtom);\n    assert(connector && address, \"connector and address are required\");\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      },\n    };\n    set(transactionsAtom, (current) => assignTx(current, txWithMeta));\n\n    if (isStandaloneTransactionItem(txWithMeta)) {\n      await set(finalizeStandaloneTxAtom, txWithMeta);\n    } else {\n      await 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      };\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    };\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","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} from \"viem\";\nimport { transactionLogger } from \"../logger\";\nimport {\n  transactionsAtom,\n  type TransactionsMap,\n  type TransactionsState,\n} from \"./transactionsAtom\";\nimport { isBatchTransactionItem, isStandaloneTransactionItem } from \"../utils\";\nimport { accountAtom } from \"@/lib/web3/wagmi/external\";\nimport { assert } from \"ts-essentials\";\n\nexport const addTxAtom = atom<null, [transaction: MinTransactionItem], void>(\n  null,\n  async (get, set, transaction) => {\n    const account = get(accountAtom);\n    assert(account, \"addTxAtom: account is required\");\n\n    const txWithMeta = {\n      ...transaction,\n      account,\n      timestamp: Date.now(),\n      dropped: false,\n    };\n    set(transactionsAtom, (current) => assignTx(current, txWithMeta));\n\n    if (isStandaloneTransactionItem(txWithMeta)) {\n      await set(finalizeStandaloneTxAtom, txWithMeta);\n    } else {\n      await 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\n  try {\n    finalizedTx.receipt = await ensureTxReceipt({\n      hash: transaction.transactionHash,\n      chainId: transaction.chainId,\n    });\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(\n        `finalizeStandaloneTxAtom::Transaction ${transaction.transactionHash} dropped with error: ${error.message}`\n      );\n    } else throw error;\n  } finally {\n    set(transactionsAtom, (current) => assignTx(current, finalizedTx));\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: transaction.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(\n        `finalizeBatchTxAtom::Batch transaction ${transaction.callsId} dropped with error: ${error.message}`\n      );\n    } else {\n      finalizedTx.callsStatus = \"failure\";\n      throw error;\n    }\n  } finally {\n    set(transactionsAtom, (current) => assignTx(current, 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    return {\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\n  return {\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\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","account","accountAtom","assert","txWithMeta","timestamp","Date","now","dropped","transactionsAtom","current","assignTx","isStandaloneTransactionItem","finalizeStandaloneTxAtom","finalizeBatchTxAtom","_","finalizedTx","ensureTxReceipt","ensureTxReceiptFactory","receipt","hash","transactionHash","chainId","error","WaitForTransactionReceiptTimeoutError","TransactionReceiptNotFoundError","CallExecutionError","transactionLogger","message","ensureCallsStatus","ensureCallsStatusFactory","receipts","status","id","callsId","callsStatus","length","WaitForCallsStatusTimeoutError","MethodNotSupportedRpcError","addTx","jotaiStore","sanitizeTx","tx","isBatchTransactionItem","action","transactionSpecificData","currentTransactions","log","accountTransactions","identifier","updatedAccountTransactions"],"mappings":";;;;;;;;;;;AA4BO,MAAMA,YAAYC,IAAAA,CACvB,IAAA,EACA,OAAOC,GAAAA,EAAKC,KAAKC,WAAAA,KAAgB;AAC/B,EAAA,MAAMC,OAAAA,GAAUH,IAAII,WAAW,CAAA;AAC/BC,EAAAA,MAAAA,CAAOF,SAAS,gCAAgC,CAAA;AAEhD,EAAA,MAAMG,UAAAA,GAAa;AAAA,IACjB,GAAGJ,WAAAA;AAAAA,IACHC,OAAAA;AAAAA,IACAI,SAAAA,EAAWC,KAAKC,GAAAA,EAAI;AAAA,IACpBC,OAAAA,EAAS;AAAA,GACX;AACAT,EAAAA,GAAAA,CAAIU,gBAAAA,EAAmBC,CAAAA,OAAAA,KAAYC,QAAAA,CAASD,OAAAA,EAASN,UAAU,CAAC,CAAA;AAEhE,EAAA,IAAIQ,2BAAAA,CAA4BR,UAAU,CAAA,EAAG;AAC3C,IAAA,MAAML,GAAAA,CAAIc,0BAA0BT,UAAU,CAAA;AAAA,EAChD,CAAA,MAAO;AACL,IAAA,MAAML,GAAAA,CAAIe,qBAAqBV,UAAU,CAAA;AAAA,EAC3C;AACF,CACF;AAEO,MAAMS,2BAA2BhB,IAAAA,CAItC,IAAA,EAAM,OAAOkB,CAAAA,EAAGhB,KAAKC,WAAAA,KAAgB;AACrC,EAAA,MAAMgB,WAAAA,GAAyC;AAAA,IAAE,GAAGhB;AAAAA,GAAY;AAChE,EAAA,MAAMiB,kBAAkBC,sBAAAA,EAAuB;AAE/C,EAAA,IAAI;AACFF,IAAAA,WAAAA,CAAYG,OAAAA,GAAU,MAAMF,eAAAA,CAAgB;AAAA,MAC1CG,MAAMpB,WAAAA,CAAYqB,eAAAA;AAAAA,MAClBC,SAAStB,WAAAA,CAAYsB;AAAAA,KACtB,CAAA;AAAA,EACH,SAASC,KAAAA,EAAO;AACd,IAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAMEA,KAAAA,YAAiBC,qCAAAA;AAAAA,MACjBD,KAAAA,YAAiBE,+BAAAA;AAAAA,MACjBF,KAAAA,YAAiBG;AAAAA,MACjB;AACAV,MAAAA,WAAAA,CAAYR,OAAAA,GAAU,IAAA;AACtBmB,MAAAA,iBAAAA,CAAkBJ,MAChB,CAAA,sCAAA,EAAyCvB,WAAAA,CAAYqB,eAAe,CAAA,qBAAA,EAAwBE,KAAAA,CAAMK,OAAO,CAAA,CAC3G,CAAA;AAAA,IACF,OAAO,MAAML,KAAAA;AAAAA,EACf,CAAA,SAAC;AACCxB,IAAAA,GAAAA,CAAIU,gBAAAA,EAAmBC,CAAAA,OAAAA,KAAYC,QAAAA,CAASD,OAAAA,EAASM,WAAW,CAAC,CAAA;AAAA,EACnE;AACF,CAAC;AAEM,MAAMF,sBAAsBjB,IAAAA,CAIjC,IAAA,EAAM,OAAOkB,CAAAA,EAAGhB,KAAKC,WAAAA,KAAgB;AACrC,EAAA,MAAMgB,WAAAA,GAAoC;AAAA,IAAE,GAAGhB;AAAAA,GAAY;AAC3D,EAAA,MAAM6B,oBAAoBC,wBAAAA,EAAyB;AAEnD,EAAA,IAAI;AACF,IAAA,MAAM;AAAA,MAAEC,QAAAA;AAAAA,MAAUC;AAAAA,KAAO,GAAI,MAAMH,iBAAAA,CAAkB;AAAA,MACnDI,IAAIjC,WAAAA,CAAYkC;AAAAA,KACjB,CAAA;AACDlB,IAAAA,WAAAA,CAAYmB,WAAAA,GAAcH,MAAAA;AAC1BhB,IAAAA,WAAAA,CAAYG,OAAAA,GAAUY,QAAAA,GAAWA,QAAAA,CAASK,MAAAA,GAAS,CAAC,CAAA;AAAA,EACtD,SAASb,KAAAA,EAAO;AACd,IAAA,IACEA,KAAAA,YAAiBc,8BAAAA,IACjBd,KAAAA,YAAiBe,0BAAAA,EACjB;AACAtB,MAAAA,WAAAA,CAAYR,OAAAA,GAAU,IAAA;AACtBmB,MAAAA,iBAAAA,CAAkBJ,MAChB,CAAA,uCAAA,EAA0CvB,WAAAA,CAAYkC,OAAO,CAAA,qBAAA,EAAwBX,KAAAA,CAAMK,OAAO,CAAA,CACpG,CAAA;AAAA,IACF,CAAA,MAAO;AACLZ,MAAAA,WAAAA,CAAYmB,WAAAA,GAAc,SAAA;AAC1B,MAAA,MAAMZ,KAAAA;AAAAA,IACR;AAAA,EACF,CAAA,SAAC;AACCxB,IAAAA,GAAAA,CAAIU,gBAAAA,EAAmBC,CAAAA,OAAAA,KAAYC,QAAAA,CAASD,OAAAA,EAASM,WAAW,CAAC,CAAA;AAAA,EACnE;AACF,CAAC;AAEM,MAAMuB,KAAAA,GAAQ,OAAOvC,WAAAA,KAAoC;AAC9D,EAAA,OAAOwC,UAAAA,CAAWzC,GAAAA,CAAIH,SAAAA,EAAWI,WAAW,CAAA;AAC9C;AAEA,SAASyC,WAAWC,EAAAA,EAAsC;AACxD,EAAA,IAAIC,sBAAAA,CAAuBD,EAAE,CAAA,EAAG;AAC9B,IAAA,OAAO;AAAA,MACLE,QAAQF,EAAAA,CAAGE,MAAAA;AAAAA,MACX3C,SAASyC,EAAAA,CAAGzC,OAAAA;AAAAA,MACZqB,SAASoB,EAAAA,CAAGpB,OAAAA;AAAAA,MACZY,SAASQ,EAAAA,CAAGR,OAAAA;AAAAA,MACZC,aAAaO,EAAAA,CAAGP,WAAAA;AAAAA,MAChB9B,WAAWqC,EAAAA,CAAGrC,SAAAA;AAAAA,MACdG,SAASkC,EAAAA,CAAGlC,OAAAA;AAAAA,MACZW,SAASuB,EAAAA,CAAGvB,OAAAA;AAAAA,MACZ0B,yBAAyBH,EAAAA,CAAGG;AAAAA,KAC9B;AAAA,EACF;AAEA,EAAA,OAAO;AAAA,IACLD,QAAQF,EAAAA,CAAGE,MAAAA;AAAAA,IACXtB,SAASoB,EAAAA,CAAGpB,OAAAA;AAAAA,IACZrB,SAASyC,EAAAA,CAAGzC,OAAAA;AAAAA,IACZoB,iBAAiBqB,EAAAA,CAAGrB,eAAAA;AAAAA,IACpBhB,WAAWqC,EAAAA,CAAGrC,SAAAA;AAAAA,IACdG,SAASkC,EAAAA,CAAGlC,OAAAA;AAAAA,IACZW,SAASuB,EAAAA,CAAGvB,OAAAA;AAAAA,IACZ0B,yBAAyBH,EAAAA,CAAGG;AAAAA,GAC9B;AACF;AAEA,SAASlC,QAAAA,CACPmC,qBACA9C,WAAAA,EACmB;AACnB2B,EAAAA,iBAAAA,CAAkBoB,IAAI,UAAA,EAAY;AAAA,IAChC9C,SAASD,WAAAA,CAAYC,OAAAA;AAAAA,IACrBD;AAAAA,GACD,CAAA;AAED,EAAA,MAAMgD,mBAAAA,GAAsBF,mBAAAA,CAAoB9C,WAAAA,CAAYC,OAAO,KAAK,EAAC;AACzE,EAAA,MAAMgD,aAAarC,2BAAAA,CAA4BZ,WAAW,CAAA,GACtDA,WAAAA,CAAYqB,kBACZrB,WAAAA,CAAYkC,OAAAA;AAEhB,EAAA,MAAMgB,0BAAAA,GAA8C;AAAA,IAClD,GAAGF,mBAAAA;AAAAA,IACH,CAACC,UAAU,GAAGR,UAAAA,CAAW;AAAA,MACvB,GAAGO,oBAAoBC,UAAU,CAAA;AAAA,MACjC,GAAGjD;AAAAA,KACJ;AAAA,GACH;AAEA,EAAA,OAAO;AAAA,IACL,GAAG8C,mBAAAA;AAAAA,IACH,CAAC9C,WAAAA,CAAYC,OAAO,GAAGiD;AAAAA,GACzB;AACF;;;;"}

package/dist/transactions/state/transactionsAtom.js

@@ -2,7 +2,7 @@ import { atomWithStorage, createJSONStorage } from 'jotai/utils';
 import { atom } from 'jotai';
 import { extractPendingTransactions, isStandaloneTransactionItem, isBatchTransactionItem, extractSwapTransactions } from '../utils.js';
 import { serialize, deserialize } from 'wagmi';
-import { addressAtom } from '../../lib/web3/wagmi/external.js';
+import { accountAtom } from '../../lib/web3/wagmi/external.js';
 import { emptyArray } from '../../lib/constants/index.js';
 import { LOCAL_STORAGE_PREFIX } from '../../lib/constants/storage.js';
 
@@ -20,7 +20,7 @@ const allTransactionsAtom = atom((get) => {
   return Object.values(transactions).flatMap((txMap) => Object.values(txMap));
 });
 const userTransactionsAtom = atom((get) => {
-  const account = get(addressAtom);
+  const account = get(accountAtom);
   if (!account) return emptyArray;
   const transactions = get(transactionsAtom)[account];
   if (!transactions) return emptyArray;

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

@@ -1 +1 @@
-{"version":3,"file":"transactionsAtom.js","sources":["../../../src/transactions/state/transactionsAtom.ts"],"sourcesContent":["import type {\n  BatchTransactionItem,\n  StandaloneTransactionItem,\n  TransactionItem,\n  TransactionItemSwap,\n} from \"../types\";\nimport { atomWithStorage, createJSONStorage } from \"jotai/utils\";\nimport { atom } from \"jotai\";\n\nimport {\n  extractPendingTransactions,\n  extractSwapTransactions,\n  isStandaloneTransactionItem,\n  isBatchTransactionItem,\n} from \"../utils\";\nimport { serialize, deserialize } from \"wagmi\";\nimport type { Address } from \"viem\";\nimport { addressAtom } from \"@/lib/web3/wagmi/external\";\nimport { emptyArray } from \"@/lib/constants\";\nimport { LOCAL_STORAGE_PREFIX } from \"@/lib/constants/storage\";\n\n//                            Record<TxHash/CallsId, TransactionItem>\nexport type TransactionsMap = Record<string, TransactionItem>;\n\nexport type TransactionsState = Record<Address, TransactionsMap>;\n\nexport const transactionsAtom = atomWithStorage<TransactionsState>(\n  `${LOCAL_STORAGE_PREFIX}_transactions`,\n  {},\n  createJSONStorage(() => localStorage, {\n    // serialize/deserialize to handle bigint values\n    replacer: (_, value) => serialize(value),\n    reviver: (_, value) => {\n      return typeof value === \"string\" ? deserialize(value) : value;\n    },\n  }),\n  { getOnInit: true }\n);\n\nexport const allTransactionsAtom = atom<TransactionItem[]>((get) => {\n  const transactions = get(transactionsAtom);\n  return Object.values(transactions).flatMap((txMap) => Object.values(txMap));\n});\n\nexport const userTransactionsAtom = atom<TransactionItem[]>((get) => {\n  const account = get(addressAtom);\n  if (!account) return emptyArray;\n  const transactions = get(transactionsAtom)[account];\n  if (!transactions) return emptyArray;\n  return Object.values(transactions);\n});\n\nexport const allStandaloneTransactionItemsAtom = atom<\n  StandaloneTransactionItem[]\n>((get) => {\n  const transactions = get(allTransactionsAtom);\n  return transactions.filter(isStandaloneTransactionItem);\n});\n\nexport const allBatchTransactionItemsAtom = atom<BatchTransactionItem[]>(\n  (get) => {\n    const transactions = get(allTransactionsAtom);\n    return transactions.filter(isBatchTransactionItem);\n  }\n);\n\nexport const allPendingStandaloneTransactionItemsAtom = atom<\n  StandaloneTransactionItem[]\n>((get) => {\n  const transactions = get(allStandaloneTransactionItemsAtom);\n  return extractPendingTransactions(transactions);\n});\n\nexport const allPendingBatchTransactionItemsAtom = atom<BatchTransactionItem[]>(\n  (get) => {\n    const transactions = get(allBatchTransactionItemsAtom);\n    return extractPendingTransactions(transactions);\n  }\n);\n\nexport const userPendingTransactionsAtom = atom<TransactionItem[]>((get) => {\n  const transactions = get(userTransactionsAtom);\n  return extractPendingTransactions(transactions);\n});\n\nexport const userSwapTransactionsAtom = atom<TransactionItemSwap[]>((get) => {\n  const transactions = get(userTransactionsAtom);\n  return extractSwapTransactions(transactions);\n});\n"],"names":["transactionsAtom","atomWithStorage","LOCAL_STORAGE_PREFIX","createJSONStorage","localStorage","replacer","_","value","serialize","reviver","deserialize","getOnInit","allTransactionsAtom","atom","get","transactions","Object","values","flatMap","txMap","userTransactionsAtom","account","addressAtom","emptyArray","allStandaloneTransactionItemsAtom","filter","isStandaloneTransactionItem","allBatchTransactionItemsAtom","isBatchTransactionItem","allPendingStandaloneTransactionItemsAtom","extractPendingTransactions","allPendingBatchTransactionItemsAtom","userPendingTransactionsAtom","userSwapTransactionsAtom","extractSwapTransactions"],"mappings":";;;;;;;;AA0BO,MAAMA,gBAAAA,GAAmBC,gBAC9B,CAAA,EAAGC,oBAAoB,iBACvB,EAAC,EACDC,iBAAAA,CAAkB,MAAMC,YAAAA,EAAc;AAAA;AAAA,EAEpCC,QAAAA,EAAUA,CAACC,CAAAA,EAAGC,KAAAA,KAAUC,UAAUD,KAAK,CAAA;AAAA,EACvCE,OAAAA,EAASA,CAACH,CAAAA,EAAGC,KAAAA,KAAU;AACrB,IAAA,OAAO,OAAOA,KAAAA,KAAU,QAAA,GAAWG,WAAAA,CAAYH,KAAK,CAAA,GAAIA,KAAAA;AAAAA,EAC1D;AACF,CAAC,CAAA,EACD;AAAA,EAAEI,SAAAA,EAAW;AAAK,CACpB;AAEO,MAAMC,mBAAAA,GAAsBC,KAAyBC,CAAAA,GAAAA,KAAQ;AAClE,EAAA,MAAMC,YAAAA,GAAeD,IAAId,gBAAgB,CAAA;AACzC,EAAA,OAAOgB,MAAAA,CAAOC,OAAOF,YAAY,CAAA,CAAEG,QAASC,CAAAA,KAAAA,KAAUH,MAAAA,CAAOC,MAAAA,CAAOE,KAAK,CAAC,CAAA;AAC5E,CAAC;AAEM,MAAMC,oBAAAA,GAAuBP,KAAyBC,CAAAA,GAAAA,KAAQ;AACnE,EAAA,MAAMO,OAAAA,GAAUP,IAAIQ,WAAW,CAAA;AAC/B,EAAA,IAAI,CAACD,SAAS,OAAOE,UAAAA;AACrB,EAAA,MAAMR,YAAAA,GAAeD,GAAAA,CAAId,gBAAgB,CAAA,CAAEqB,OAAO,CAAA;AAClD,EAAA,IAAI,CAACN,cAAc,OAAOQ,UAAAA;AAC1B,EAAA,OAAOP,MAAAA,CAAOC,OAAOF,YAAY,CAAA;AACnC,CAAC;AAEM,MAAMS,iCAAAA,GAAoCX,KAE9CC,CAAAA,GAAAA,KAAQ;AACT,EAAA,MAAMC,YAAAA,GAAeD,IAAIF,mBAAmB,CAAA;AAC5C,EAAA,OAAOG,YAAAA,CAAaU,OAAOC,2BAA2B,CAAA;AACxD,CAAC;AAEM,MAAMC,4BAAAA,GAA+Bd,KACzCC,CAAAA,GAAAA,KAAQ;AACP,EAAA,MAAMC,YAAAA,GAAeD,IAAIF,mBAAmB,CAAA;AAC5C,EAAA,OAAOG,YAAAA,CAAaU,OAAOG,sBAAsB,CAAA;AACnD,CACF;AAEO,MAAMC,wCAAAA,GAA2ChB,KAErDC,CAAAA,GAAAA,KAAQ;AACT,EAAA,MAAMC,YAAAA,GAAeD,IAAIU,iCAAiC,CAAA;AAC1D,EAAA,OAAOM,2BAA2Bf,YAAY,CAAA;AAChD,CAAC;AAEM,MAAMgB,mCAAAA,GAAsClB,KAChDC,CAAAA,GAAAA,KAAQ;AACP,EAAA,MAAMC,YAAAA,GAAeD,IAAIa,4BAA4B,CAAA;AACrD,EAAA,OAAOG,2BAA2Bf,YAAY,CAAA;AAChD,CACF;AAEO,MAAMiB,2BAAAA,GAA8BnB,KAAyBC,CAAAA,GAAAA,KAAQ;AAC1E,EAAA,MAAMC,YAAAA,GAAeD,IAAIM,oBAAoB,CAAA;AAC7C,EAAA,OAAOU,2BAA2Bf,YAAY,CAAA;AAChD,CAAC;AAEM,MAAMkB,wBAAAA,GAA2BpB,KAA6BC,CAAAA,GAAAA,KAAQ;AAC3E,EAAA,MAAMC,YAAAA,GAAeD,IAAIM,oBAAoB,CAAA;AAC7C,EAAA,OAAOc,wBAAwBnB,YAAY,CAAA;AAC7C,CAAC;;;;"}
+{"version":3,"file":"transactionsAtom.js","sources":["../../../src/transactions/state/transactionsAtom.ts"],"sourcesContent":["import type {\n  BatchTransactionItem,\n  StandaloneTransactionItem,\n  TransactionItem,\n  TransactionItemSwap,\n} from \"../types\";\nimport { atomWithStorage, createJSONStorage } from \"jotai/utils\";\nimport { atom } from \"jotai\";\n\nimport {\n  extractPendingTransactions,\n  extractSwapTransactions,\n  isStandaloneTransactionItem,\n  isBatchTransactionItem,\n} from \"../utils\";\nimport { serialize, deserialize } from \"wagmi\";\nimport type { Address } from \"viem\";\nimport { accountAtom } from \"@/lib/web3/wagmi/external\";\nimport { emptyArray } from \"@/lib/constants\";\nimport { LOCAL_STORAGE_PREFIX } from \"@/lib/constants/storage\";\n\n//                            Record<TxHash/CallsId, TransactionItem>\nexport type TransactionsMap = Record<string, TransactionItem>;\n\nexport type TransactionsState = Record<Address, TransactionsMap>;\n\nexport const transactionsAtom = atomWithStorage<TransactionsState>(\n  `${LOCAL_STORAGE_PREFIX}_transactions`,\n  {},\n  createJSONStorage(() => localStorage, {\n    // serialize/deserialize to handle bigint values\n    replacer: (_, value) => serialize(value),\n    reviver: (_, value) => {\n      return typeof value === \"string\" ? deserialize(value) : value;\n    },\n  }),\n  { getOnInit: true }\n);\n\nexport const allTransactionsAtom = atom<TransactionItem[]>((get) => {\n  const transactions = get(transactionsAtom);\n  return Object.values(transactions).flatMap((txMap) => Object.values(txMap));\n});\n\nexport const userTransactionsAtom = atom<TransactionItem[]>((get) => {\n  const account = get(accountAtom);\n  if (!account) return emptyArray;\n  const transactions = get(transactionsAtom)[account];\n  if (!transactions) return emptyArray;\n  return Object.values(transactions);\n});\n\nexport const allStandaloneTransactionItemsAtom = atom<\n  StandaloneTransactionItem[]\n>((get) => {\n  const transactions = get(allTransactionsAtom);\n  return transactions.filter(isStandaloneTransactionItem);\n});\n\nexport const allBatchTransactionItemsAtom = atom<BatchTransactionItem[]>(\n  (get) => {\n    const transactions = get(allTransactionsAtom);\n    return transactions.filter(isBatchTransactionItem);\n  }\n);\n\nexport const allPendingStandaloneTransactionItemsAtom = atom<\n  StandaloneTransactionItem[]\n>((get) => {\n  const transactions = get(allStandaloneTransactionItemsAtom);\n  return extractPendingTransactions(transactions);\n});\n\nexport const allPendingBatchTransactionItemsAtom = atom<BatchTransactionItem[]>(\n  (get) => {\n    const transactions = get(allBatchTransactionItemsAtom);\n    return extractPendingTransactions(transactions);\n  }\n);\n\nexport const userPendingTransactionsAtom = atom<TransactionItem[]>((get) => {\n  const transactions = get(userTransactionsAtom);\n  return extractPendingTransactions(transactions);\n});\n\nexport const userSwapTransactionsAtom = atom<TransactionItemSwap[]>((get) => {\n  const transactions = get(userTransactionsAtom);\n  return extractSwapTransactions(transactions);\n});\n"],"names":["transactionsAtom","atomWithStorage","LOCAL_STORAGE_PREFIX","createJSONStorage","localStorage","replacer","_","value","serialize","reviver","deserialize","getOnInit","allTransactionsAtom","atom","get","transactions","Object","values","flatMap","txMap","userTransactionsAtom","account","accountAtom","emptyArray","allStandaloneTransactionItemsAtom","filter","isStandaloneTransactionItem","allBatchTransactionItemsAtom","isBatchTransactionItem","allPendingStandaloneTransactionItemsAtom","extractPendingTransactions","allPendingBatchTransactionItemsAtom","userPendingTransactionsAtom","userSwapTransactionsAtom","extractSwapTransactions"],"mappings":";;;;;;;;AA0BO,MAAMA,gBAAAA,GAAmBC,gBAC9B,CAAA,EAAGC,oBAAoB,iBACvB,EAAC,EACDC,iBAAAA,CAAkB,MAAMC,YAAAA,EAAc;AAAA;AAAA,EAEpCC,QAAAA,EAAUA,CAACC,CAAAA,EAAGC,KAAAA,KAAUC,UAAUD,KAAK,CAAA;AAAA,EACvCE,OAAAA,EAASA,CAACH,CAAAA,EAAGC,KAAAA,KAAU;AACrB,IAAA,OAAO,OAAOA,KAAAA,KAAU,QAAA,GAAWG,WAAAA,CAAYH,KAAK,CAAA,GAAIA,KAAAA;AAAAA,EAC1D;AACF,CAAC,CAAA,EACD;AAAA,EAAEI,SAAAA,EAAW;AAAK,CACpB;AAEO,MAAMC,mBAAAA,GAAsBC,KAAyBC,CAAAA,GAAAA,KAAQ;AAClE,EAAA,MAAMC,YAAAA,GAAeD,IAAId,gBAAgB,CAAA;AACzC,EAAA,OAAOgB,MAAAA,CAAOC,OAAOF,YAAY,CAAA,CAAEG,QAASC,CAAAA,KAAAA,KAAUH,MAAAA,CAAOC,MAAAA,CAAOE,KAAK,CAAC,CAAA;AAC5E,CAAC;AAEM,MAAMC,oBAAAA,GAAuBP,KAAyBC,CAAAA,GAAAA,KAAQ;AACnE,EAAA,MAAMO,OAAAA,GAAUP,IAAIQ,WAAW,CAAA;AAC/B,EAAA,IAAI,CAACD,SAAS,OAAOE,UAAAA;AACrB,EAAA,MAAMR,YAAAA,GAAeD,GAAAA,CAAId,gBAAgB,CAAA,CAAEqB,OAAO,CAAA;AAClD,EAAA,IAAI,CAACN,cAAc,OAAOQ,UAAAA;AAC1B,EAAA,OAAOP,MAAAA,CAAOC,OAAOF,YAAY,CAAA;AACnC,CAAC;AAEM,MAAMS,iCAAAA,GAAoCX,KAE9CC,CAAAA,GAAAA,KAAQ;AACT,EAAA,MAAMC,YAAAA,GAAeD,IAAIF,mBAAmB,CAAA;AAC5C,EAAA,OAAOG,YAAAA,CAAaU,OAAOC,2BAA2B,CAAA;AACxD,CAAC;AAEM,MAAMC,4BAAAA,GAA+Bd,KACzCC,CAAAA,GAAAA,KAAQ;AACP,EAAA,MAAMC,YAAAA,GAAeD,IAAIF,mBAAmB,CAAA;AAC5C,EAAA,OAAOG,YAAAA,CAAaU,OAAOG,sBAAsB,CAAA;AACnD,CACF;AAEO,MAAMC,wCAAAA,GAA2ChB,KAErDC,CAAAA,GAAAA,KAAQ;AACT,EAAA,MAAMC,YAAAA,GAAeD,IAAIU,iCAAiC,CAAA;AAC1D,EAAA,OAAOM,2BAA2Bf,YAAY,CAAA;AAChD,CAAC;AAEM,MAAMgB,mCAAAA,GAAsClB,KAChDC,CAAAA,GAAAA,KAAQ;AACP,EAAA,MAAMC,YAAAA,GAAeD,IAAIa,4BAA4B,CAAA;AACrD,EAAA,OAAOG,2BAA2Bf,YAAY,CAAA;AAChD,CACF;AAEO,MAAMiB,2BAAAA,GAA8BnB,KAAyBC,CAAAA,GAAAA,KAAQ;AAC1E,EAAA,MAAMC,YAAAA,GAAeD,IAAIM,oBAAoB,CAAA;AAC7C,EAAA,OAAOU,2BAA2Bf,YAAY,CAAA;AAChD,CAAC;AAEM,MAAMkB,wBAAAA,GAA2BpB,KAA6BC,CAAAA,GAAAA,KAAQ;AAC3E,EAAA,MAAMC,YAAAA,GAAeD,IAAIM,oBAAoB,CAAA;AAC7C,EAAA,OAAOc,wBAAwBnB,YAAY,CAAA;AAC7C,CAAC;;;;"}