npm - @velora-dex/widget - Versions diffs - 0.3.5 → 0.3.7-dev.1 - Mend

@velora-dex/widget 0.3.5 → 0.3.7-dev.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (137) hide show

package/dist/lib/web3/wagmi/external.js CHANGED Viewed

@@ -1,8 +1,23 @@
 import { getAccount } from '@wagmi/core';
 import { wagmiConfig } from './config.js';
 import { atom } from 'jotai';
+import { atomWithCompare } from '../../utils/atomWithCompare.js';
+import { constructPropertiesEqual } from '../../utils/index.js';
-const accountAtom = atom(getAccount(wagmiConfig).address);
+function getMinAccount() {
+  const {
+    address,
+    chainId,
+    connector
+  } = getAccount(wagmiConfig);
+  return {
+    address,
+    chainId,
+    connector
+  };
+}
+const accountAtom = atomWithCompare(getMinAccount(), constructPropertiesEqual(["address", "chainId", "connector"]));
+const addressAtom = atom((get) => get(accountAtom).address);
-export { accountAtom };
+export { accountAtom, addressAtom };
 //# sourceMappingURL=external.js.map

package/dist/lib/web3/wagmi/external.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"external.js","sources":["../../../../src/lib/web3/wagmi/external.ts"],"sourcesContent":["import { getAccount } from \"@wagmi/core\";\nimport { wagmiConfig } from \"./config\";\nimport { atom } from \"jotai\";\n\nexport const accountAtom = atom(~~getAccount~~(~~wagmiConfig~~).address);\n"],"names":["~~accountAtom~~","~~atom~~","getAccount","wagmiConfig","~~address~~"],"mappings":"~~;;;;AAIO~~,~~MAAMA~~,WAAAA,GAAcC,IAAAA,~~CAAKC~~,~~UAAAA~~,~~CAAWC~~,WAAW,~~EAAEC~~,OAAO;;;;"}
1	+ {"version":3,"file":"external.js","sources":["../../../../src/lib/web3/wagmi/external.ts"],"sourcesContent":["import { getAccount } from \"@wagmi/core\";\nimport { wagmiConfig } from \"./config\";\nimport { atom } from \"jotai\";\nimport { atomWithCompare } from \"@/lib/utils/atomWithCompare\";\nimport { constructPropertiesEqual } from \"@/lib/utils\";\n\nfunction getMinAccount() {\n const { address, chainId, connector } = getAccount(wagmiConfig);\n return { address, chainId, connector };\n}\n\nexport const accountAtom = atomWithCompare(\n getMinAccount(),\n constructPropertiesEqual([\"address\", \"chainId\", \"connector\"])\n);\n\nexport const addressAtom = atom((get) => get(accountAtom).address);\n"],"names":["getMinAccount","address","chainId","connector","getAccount","wagmiConfig","accountAtom","atomWithCompare","constructPropertiesEqual","addressAtom","atom","get"],"mappings":";;;;;;AAMA,SAASA,aAAAA,GAAgB;AACvB,EAAA,MAAM;AAAA,IAAEC,OAAAA;AAAAA,IAASC,OAAAA;AAAAA,IAASC;AAAAA,GAAU,GAAIC,WAAWC,WAAW,CAAA;AAC9D,EAAA,OAAO;AAAA,IAAEJ,OAAAA;AAAAA,IAASC,OAAAA;AAAAA,IAASC;AAAAA,GAAU;AACvC;AAEO,MAAMG,WAAAA,GAAcC,eAAAA,CACzBP,aAAAA,EAAc,EACdQ,wBAAAA,CAAyB,CAAC,SAAA,EAAW,SAAA,EAAW,WAAW,CAAC,CAC9D;AAEO,MAAMC,cAAcC,IAAAA,CAAMC,CAAAA,GAAAA,KAAQA,GAAAA,CAAIL,WAAW,EAAEL,OAAO;;;;"}

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

	@@ -1 +1 @@
1	- {"version":3,"file":"switchChain.d.ts","sourceRoot":"","sources":["../../../../src/lib/web3/wagmi/switchChain.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;~~AAGhD~~,wBAAsB,WAAW,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,gBAAgB,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~qCAU85E~~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~~eADp4W~~"}
1	+ {"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 CHANGED Viewed

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

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

	@@ -1 +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\";\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;;;;"}
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 { isExternalConnectorWithSafeIframe } from \"@/core/state/externalProviderAtom\";\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 (\n !isSafe &&\n connector &&\n (await isExternalConnectorWithSafeIframe(connector))\n ) {\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","isExternalConnectorWithSafeIframe","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,IACE,CAACK,MAAAA,IACDL,SAAAA,IACC,MAAMO,iCAAAA,CAAkCP,SAAS,CAAA,EAClD;AACAK,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;;;;"}

package/dist/styles.css CHANGED Viewed

@@ -70,7 +70,7 @@
     }
   }
 }
-:root, :host {
+.velora-widget {
   --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/tokens/state/allTokensByChainAtom.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"allTokensByChainAtom.d.ts","sourceRoot":"","sources":["../../../src/tokens/state/allTokensByChainAtom.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE3E,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAK5D,eAAO,MAAM,oBAAoB,~~2EAyD~~/B,CAAC"}
1	+ {"version":3,"file":"allTokensByChainAtom.d.ts","sourceRoot":"","sources":["../../../src/tokens/state/allTokensByChainAtom.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAE3E,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAK5D,eAAO,MAAM,oBAAoB,2EA2D/B,CAAC"}

package/dist/tokens/state/allTokensByChainAtom.js CHANGED Viewed

@@ -1,7 +1,6 @@
 import { atom } from 'jotai';
 import { fromListsAtom } from './fromListsAtom.js';
 import { importedTokensAtom } from './importedTokensAtom.js';
-import { getLogger } from '../../core/logger.js';
 import { gatherObjectsByProp } from '../../lib/utils/index.js';
 const allTokensByChainAtom = atom((get) => {
@@ -26,8 +25,6 @@ const allTokensByChainAtom = atom((get) => {
         tokens.push(token);
         addressMap[addressKey] = token;
         result.tokensFromAllChains.push(token);
-      } else {
-        getLogger("AllTokensByChain").log(`LOGIC ERROR: Token ${token.address} on chain ${chainId} already exists in fromListsAtom, skipping import.`);
       }
     }
     result.listByChainId[chainId] = {

package/dist/tokens/state/allTokensByChainAtom.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"allTokensByChainAtom.js","sources":["../../../src/tokens/state/allTokensByChainAtom.ts"],"sourcesContent":["import { atom } from \"jotai\";\nimport { fromListsAtom, type TokensFromListsState } from \"./fromListsAtom\";\nimport { importedTokensAtom } from \"./importedTokensAtom\";\nimport type { ImportedToken, TokenFromList } from \"./types\";\~~nimport~~ { getLogger } from \"@/core/logger\";\nimport { gatherObjectsByProp } from \"@/lib/utils\";\n\n// returns TokenFromListState + ImportedTokenState merged, conforming the shape of the first one\nexport const allTokensByChainAtom = atom((get) => {\n const fromListsState = get(fromListsAtom);\n const importedByChain = get(importedTokensAtom);\n\n // start with a fresh result object to avoid mutating fromListsState\n const result: TokensFromListsState<TokenFromList \| ImportedToken> = {\n listByChainId: {},\n // disabledListByChainId won't be deep-changed, so clone shallowly\n disabledListByChainId: fromListsState.disabledListByChainId,\n tokensFromAllChains: fromListsState.tokensFromAllChains.slice(),\n };\n\n // merge tokens list & map for chains present in fromListsState\n for (const [chainIdStr, fromListsArr] of Object.entries(\n fromListsState.listByChainId\n )) {\n const chainId = Number(chainIdStr);\n const imported = importedByChain[chainId] \|\| [];\n\n // clone base tokens and addressMap to avoid mutation\n const tokens: (TokenFromList \| ImportedToken)[] =\n fromListsArr.tokens.slice();\n const addressMap: { [address: string]: TokenFromList \| ImportedToken } = {\n ...fromListsArr.addressMap,\n };\n\n // add imported tokens if not already present\n for (const token of imported) {\n const addressKey = token.address.toLowerCase();\n if (!addressMap[addressKey]) {\n tokens.push(token);\n addressMap[addressKey] = token;\n\n // add imported to all Tokens\n result.tokensFromAllChains.push(token);\n } else {\n getLogger(\"AllTokensByChain\").log(\n `LOGIC ERROR: Token ${token.address} on chain ${chainId} already exists in fromListsAtom, skipping import.`\n );\n }\n }\n\n result.listByChainId[chainId] = { tokens, addressMap };\n }\n\n // normally shouldn't happen, but add chains that only have imported tokens\n for (const [chainIdStr, importedArr] of Object.entries(importedByChain)) {\n const chainId = Number(chainIdStr);\n if (!result.listByChainId[chainId]) {\n const addressMap = gatherObjectsByProp(importedArr, (token) =>\n token.address.toLowerCase()\n );\n result.listByChainId[chainId] = { tokens: importedArr, addressMap };\n }\n }\n\n return result;\n});\n"],"names":["allTokensByChainAtom","atom","get","fromListsState","fromListsAtom","importedByChain","importedTokensAtom","result","listByChainId","disabledListByChainId","tokensFromAllChains","slice","chainIdStr","fromListsArr","Object","entries","chainId","Number","imported","tokens","addressMap","token","addressKey","address","toLowerCase","push","~~getLogger","log","~~importedArr","gatherObjectsByProp"],"mappings":"~~;;;;;;~~AAQO,MAAMA,oBAAAA,GAAuBC,KAAMC,CAAAA,GAAAA,KAAQ;AAChD,EAAA,MAAMC,cAAAA,GAAiBD,IAAIE,aAAa,CAAA;AACxC,EAAA,MAAMC,eAAAA,GAAkBH,IAAII,kBAAkB,CAAA;AAG9C,EAAA,MAAMC,MAAAA,GAA8D;AAAA,IAClEC,eAAe,EAAC;AAAA;AAAA,IAEhBC,uBAAuBN,cAAAA,CAAeM,qBAAAA;AAAAA,IACtCC,mBAAAA,EAAqBP,cAAAA,CAAeO,mBAAAA,CAAoBC,KAAAA;AAAM,GAChE;AAGA,EAAA,KAAA,MAAW,CAACC,YAAYC,YAAY,CAAA,IAAKC,OAAOC,OAAAA,CAC9CZ,cAAAA,CAAeK,aACjB,CAAA,EAAG;AACD,IAAA,MAAMQ,OAAAA,GAAUC,OAAOL,UAAU,CAAA;AACjC,IAAA,MAAMM,QAAAA,GAAWb,eAAAA,CAAgBW,OAAO,CAAA,IAAK,EAAA;AAG7C,IAAA,MAAMG,MAAAA,GACJN,YAAAA,CAAaM,MAAAA,CAAOR,KAAAA,EAAM;AAC5B,IAAA,MAAMS,UAAAA,GAAmE;AAAA,MACvE,GAAGP,YAAAA,CAAaO;AAAAA,KAClB;AAGA,IAAA,KAAA,MAAWC,SAASH,QAAAA,EAAU;AAC5B,MAAA,MAAMI,UAAAA,GAAaD,KAAAA,CAAME,OAAAA,CAAQC,WAAAA,EAAY;AAC7C,MAAA,IAAI,CAACJ,UAAAA,CAAWE,UAAU,CAAA,EAAG;AAC3BH,QAAAA,MAAAA,CAAOM,KAAKJ,KAAK,CAAA;AACjBD,QAAAA,UAAAA,CAAWE,UAAU,CAAA,GAAID,KAAAA;AAGzBd,QAAAA,MAAAA,CAAOG,mBAAAA,CAAoBe,KAAKJ,KAAK,CAAA;AAAA,MACvC~~,CAAA,MAAO~~;~~AACLK,QAAAA,SAAAA,CAAU,kBAAkB,EAAEC,GAAAA,CAC5B,CAAA,mBAAA,EAAsBN,MAAME,OAAO,CAAA,UAAA,EAAaP,OAAO,CAAA,kDAAA,CACzD,CAAA;~~AAAA,~~MACF~~;~~AAAA~~,~~IACF;AAEAT,~~IAAAA,MAAAA,CAAOC,aAAAA,CAAcQ,OAAO,CAAA,GAAI;AAAA,MAAEG,MAAAA;AAAAA,MAAQC;AAAAA,KAAW;AAAA,EACvD;AAGA,EAAA,KAAA,MAAW,CAACR,UAAAA,~~EAAYgB~~,WAAW,~~KAAKd~~,MAAAA,CAAOC,OAAAA,CAAQV,eAAe,CAAA,EAAG;AACvE,IAAA,MAAMW,OAAAA,GAAUC,OAAOL,UAAU,CAAA;AACjC,IAAA,IAAI,CAACL,MAAAA,CAAOC,aAAAA,CAAcQ,OAAO,CAAA,EAAG;AAClC,MAAA,MAAMI,~~aAAaS~~,mBAAAA,CAAoBD,WAAAA,~~EAAcP~~,WACnDA,KAAAA,CAAME,OAAAA,CAAQC,aAChB,CAAA;AACAjB,MAAAA,MAAAA,CAAOC,aAAAA,CAAcQ,OAAO,CAAA,GAAI;AAAA,QAAEG,MAAAA,~~EAAQS~~,WAAAA;AAAAA,~~QAAaR~~;AAAAA,OAAW;AAAA,IACpE;AAAA,EACF;AAEA,EAAA,OAAOb,MAAAA;AACT,CAAC;;;;"}
1	+ {"version":3,"file":"allTokensByChainAtom.js","sources":["../../../src/tokens/state/allTokensByChainAtom.ts"],"sourcesContent":["import { atom } from \"jotai\";\nimport { fromListsAtom, type TokensFromListsState } from \"./fromListsAtom\";\nimport { importedTokensAtom } from \"./importedTokensAtom\";\nimport type { ImportedToken, TokenFromList } from \"./types\";\n// import { getLogger } from \"@/core/logger\";\nimport { gatherObjectsByProp } from \"@/lib/utils\";\n\n// returns TokenFromListState + ImportedTokenState merged, conforming the shape of the first one\nexport const allTokensByChainAtom = atom((get) => {\n const fromListsState = get(fromListsAtom);\n const importedByChain = get(importedTokensAtom);\n\n // start with a fresh result object to avoid mutating fromListsState\n const result: TokensFromListsState<TokenFromList \| ImportedToken> = {\n listByChainId: {},\n // disabledListByChainId won't be deep-changed, so clone shallowly\n disabledListByChainId: fromListsState.disabledListByChainId,\n tokensFromAllChains: fromListsState.tokensFromAllChains.slice(),\n };\n\n // merge tokens list & map for chains present in fromListsState\n for (const [chainIdStr, fromListsArr] of Object.entries(\n fromListsState.listByChainId\n )) {\n const chainId = Number(chainIdStr);\n const imported = importedByChain[chainId] \|\| [];\n\n // clone base tokens and addressMap to avoid mutation\n const tokens: (TokenFromList \| ImportedToken)[] =\n fromListsArr.tokens.slice();\n const addressMap: { [address: string]: TokenFromList \| ImportedToken } = {\n ...fromListsArr.addressMap,\n };\n\n // add imported tokens if not already present\n for (const token of imported) {\n const addressKey = token.address.toLowerCase();\n if (!addressMap[addressKey]) {\n tokens.push(token);\n addressMap[addressKey] = token;\n\n // add imported to all Tokens\n result.tokensFromAllChains.push(token);\n }\n // @TODO: suppressing the logs for now as it clutters the console\n // else {\n // getLogger(\"AllTokensByChain\").log(\n // `LOGIC ERROR: Token ${token.address} on chain ${chainId} already exists in fromListsAtom, skipping import.`\n // );\n // }\n }\n\n result.listByChainId[chainId] = { tokens, addressMap };\n }\n\n // normally shouldn't happen, but add chains that only have imported tokens\n for (const [chainIdStr, importedArr] of Object.entries(importedByChain)) {\n const chainId = Number(chainIdStr);\n if (!result.listByChainId[chainId]) {\n const addressMap = gatherObjectsByProp(importedArr, (token) =>\n token.address.toLowerCase()\n );\n result.listByChainId[chainId] = { tokens: importedArr, addressMap };\n }\n }\n\n return result;\n});\n"],"names":["allTokensByChainAtom","atom","get","fromListsState","fromListsAtom","importedByChain","importedTokensAtom","result","listByChainId","disabledListByChainId","tokensFromAllChains","slice","chainIdStr","fromListsArr","Object","entries","chainId","Number","imported","tokens","addressMap","token","addressKey","address","toLowerCase","push","importedArr","gatherObjectsByProp"],"mappings":";;;;;AAQO,MAAMA,oBAAAA,GAAuBC,KAAMC,CAAAA,GAAAA,KAAQ;AAChD,EAAA,MAAMC,cAAAA,GAAiBD,IAAIE,aAAa,CAAA;AACxC,EAAA,MAAMC,eAAAA,GAAkBH,IAAII,kBAAkB,CAAA;AAG9C,EAAA,MAAMC,MAAAA,GAA8D;AAAA,IAClEC,eAAe,EAAC;AAAA;AAAA,IAEhBC,uBAAuBN,cAAAA,CAAeM,qBAAAA;AAAAA,IACtCC,mBAAAA,EAAqBP,cAAAA,CAAeO,mBAAAA,CAAoBC,KAAAA;AAAM,GAChE;AAGA,EAAA,KAAA,MAAW,CAACC,YAAYC,YAAY,CAAA,IAAKC,OAAOC,OAAAA,CAC9CZ,cAAAA,CAAeK,aACjB,CAAA,EAAG;AACD,IAAA,MAAMQ,OAAAA,GAAUC,OAAOL,UAAU,CAAA;AACjC,IAAA,MAAMM,QAAAA,GAAWb,eAAAA,CAAgBW,OAAO,CAAA,IAAK,EAAA;AAG7C,IAAA,MAAMG,MAAAA,GACJN,YAAAA,CAAaM,MAAAA,CAAOR,KAAAA,EAAM;AAC5B,IAAA,MAAMS,UAAAA,GAAmE;AAAA,MACvE,GAAGP,YAAAA,CAAaO;AAAAA,KAClB;AAGA,IAAA,KAAA,MAAWC,SAASH,QAAAA,EAAU;AAC5B,MAAA,MAAMI,UAAAA,GAAaD,KAAAA,CAAME,OAAAA,CAAQC,WAAAA,EAAY;AAC7C,MAAA,IAAI,CAACJ,UAAAA,CAAWE,UAAU,CAAA,EAAG;AAC3BH,QAAAA,MAAAA,CAAOM,KAAKJ,KAAK,CAAA;AACjBD,QAAAA,UAAAA,CAAWE,UAAU,CAAA,GAAID,KAAAA;AAGzBd,QAAAA,MAAAA,CAAOG,mBAAAA,CAAoBe,KAAKJ,KAAK,CAAA;AAAA,MACvC;AAAA,IAOF;AAEAd,IAAAA,MAAAA,CAAOC,aAAAA,CAAcQ,OAAO,CAAA,GAAI;AAAA,MAAEG,MAAAA;AAAAA,MAAQC;AAAAA,KAAW;AAAA,EACvD;AAGA,EAAA,KAAA,MAAW,CAACR,UAAAA,EAAYc,WAAW,KAAKZ,MAAAA,CAAOC,OAAAA,CAAQV,eAAe,CAAA,EAAG;AACvE,IAAA,MAAMW,OAAAA,GAAUC,OAAOL,UAAU,CAAA;AACjC,IAAA,IAAI,CAACL,MAAAA,CAAOC,aAAAA,CAAcQ,OAAO,CAAA,EAAG;AAClC,MAAA,MAAMI,aAAaO,mBAAAA,CAAoBD,WAAAA,EAAcL,WACnDA,KAAAA,CAAME,OAAAA,CAAQC,aAChB,CAAA;AACAjB,MAAAA,MAAAA,CAAOC,aAAAA,CAAcQ,OAAO,CAAA,GAAI;AAAA,QAAEG,MAAAA,EAAQO,WAAAA;AAAAA,QAAaN;AAAAA,OAAW;AAAA,IACpE;AAAA,EACF;AAEA,EAAA,OAAOb,MAAAA;AACT,CAAC;;;;"}

package/dist/transactions/hash.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import { Hash } from 'viem';
+import { TransactionItem } from './types';
+export declare function getStandaloneTxHash({ transactionHash, }: {
+    transactionHash?: Hash;
+}): Hash | null;
+export declare function getTxHash(tx: TransactionItem): Hash | null;
+//# sourceMappingURL=hash.d.ts.map

package/dist/transactions/hash.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/transactions/hash.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,KAAK,EAA6B,eAAe,EAAE,MAAM,SAAS,CAAC;AAa1E,wBAAgB,mBAAmB,CAAC,EAClC,eAAe,GAChB,EAAE;IACD,eAAe,CAAC,EAAE,IAAI,CAAC;CACxB,GAAG,IAAI,GAAG,IAAI,CAKd;AAED,wBAAgB,SAAS,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI,CAgB1D"}

package/dist/transactions/hash.js ADDED Viewed

@@ -0,0 +1,35 @@
+import { jotaiStore } from '../core/store.js';
+import { isBatchTransactionItem } from './utils.js';
+import { allStandaloneTransactionItemsAtom } from './state/transactionsAtom.js';
+import { isSafeConnector } from '../hooks/connectors/useIsGnosisSafeConnector.js';
+function findStandaloneTx({
+  transactionHash
+}) {
+  return jotaiStore.get(allStandaloneTransactionItemsAtom).find((tx) => tx.transactionHash === transactionHash);
+}
+function getStandaloneTxHash({
+  transactionHash
+}) {
+  if (!transactionHash) return null;
+  const tx = findStandaloneTx({
+    transactionHash
+  });
+  if (!tx) return null;
+  return getTxHash(tx);
+}
+function getTxHash(tx) {
+  if (tx.receipt?.transactionHash) {
+    return tx.receipt.transactionHash;
+  }
+  if (isBatchTransactionItem(tx)) {
+    return tx.receipt?.transactionHash || null;
+  }
+  if (tx.connectorData && isSafeConnector(tx.connectorData)) {
+    return tx.receipt?.transactionHash || null;
+  }
+  return tx.transactionHash;
+}
+export { getStandaloneTxHash, getTxHash };
+//# sourceMappingURL=hash.js.map

package/dist/transactions/hash.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"hash.js","sources":["../../src/transactions/hash.ts"],"sourcesContent":["import { jotaiStore } from \"@/core/store\";\nimport type { Hash } from \"viem\";\nimport type { StandaloneTransactionItem, TransactionItem } from \"./types\";\nimport { isBatchTransactionItem } from \"./utils\";\nimport { allStandaloneTransactionItemsAtom } from \"./state/transactionsAtom\";\nimport { isSafeConnector } from \"@/hooks/connectors/useIsGnosisSafeConnector\";\n\nfunction findStandaloneTx({\n transactionHash,\n}: Pick<StandaloneTransactionItem, \"transactionHash\">) {\n return jotaiStore\n .get(allStandaloneTransactionItemsAtom)\n .find((tx) => tx.transactionHash === transactionHash);\n}\n\nexport function getStandaloneTxHash({\n transactionHash,\n}: {\n transactionHash?: Hash;\n}): Hash | null {\n if (!transactionHash) return null;\n const tx = findStandaloneTx({ transactionHash });\n if (!tx) return null;\n return getTxHash(tx);\n}\n\nexport function getTxHash(tx: TransactionItem): Hash | null {\n if (tx.receipt?.transactionHash) {\n // if tx is mined, receipt is always the source of truth for the transaction hash\n return tx.receipt.transactionHash;\n }\n if (isBatchTransactionItem(tx)) {\n // for batch transactions, we have the real transaction hash in the receipt when the batch is mined\n return tx.receipt?.transactionHash || null;\n }\n if (tx.connectorData && isSafeConnector(tx.connectorData)) {\n // for Safe transactions sent through Safe iframe provider,\n // we don't have the real transaction hash until the transaction is mined\n return tx.receipt?.transactionHash || null;\n }\n\n return tx.transactionHash;\n}\n"],"names":["findStandaloneTx","transactionHash","jotaiStore","get","allStandaloneTransactionItemsAtom","find","tx","getStandaloneTxHash","getTxHash","receipt","isBatchTransactionItem","connectorData","isSafeConnector"],"mappings":";;;;;AAOA,SAASA,gBAAAA,CAAiB;AAAA,EACxBC;AACkD,CAAA,EAAG;AACrD,EAAA,OAAOC,UAAAA,CACJC,IAAIC,iCAAiC,CAAA,CACrCC,KAAMC,CAAAA,EAAAA,KAAOA,EAAAA,CAAGL,oBAAoBA,eAAe,CAAA;AACxD;AAEO,SAASM,mBAAAA,CAAoB;AAAA,EAClCN;AAGF,CAAA,EAAgB;AACd,EAAA,IAAI,CAACA,iBAAiB,OAAO,IAAA;AAC7B,EAAA,MAAMK,KAAKN,gBAAAA,CAAiB;AAAA,IAAEC;AAAAA,GAAiB,CAAA;AAC/C,EAAA,IAAI,CAACK,IAAI,OAAO,IAAA;AAChB,EAAA,OAAOE,UAAUF,EAAE,CAAA;AACrB;AAEO,SAASE,UAAUF,EAAAA,EAAkC;AAC1D,EAAA,IAAIA,EAAAA,CAAGG,SAASR,eAAAA,EAAiB;AAE/B,IAAA,OAAOK,GAAGG,OAAAA,CAAQR,eAAAA;AAAAA,EACpB;AACA,EAAA,IAAIS,sBAAAA,CAAuBJ,EAAE,CAAA,EAAG;AAE9B,IAAA,OAAOA,EAAAA,CAAGG,SAASR,eAAAA,IAAmB,IAAA;AAAA,EACxC;AACA,EAAA,IAAIK,EAAAA,CAAGK,aAAAA,IAAiBC,eAAAA,CAAgBN,EAAAA,CAAGK,aAAa,CAAA,EAAG;AAGzD,IAAA,OAAOL,EAAAA,CAAGG,SAASR,eAAAA,IAAmB,IAAA;AAAA,EACxC;AAEA,EAAA,OAAOK,EAAAA,CAAGL,eAAAA;AACZ;;;;"}

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

	@@ -1 +1 @@
1	- {"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"}
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,wBAkCpC,CAAC"}

package/dist/transactions/queries/ensureCallsStatus.js CHANGED Viewed

@@ -1,21 +1,29 @@
+import { isExternalConnectorWithSafeIframe } from '../../core/state/externalProviderAtom.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 { waitForCallsStatus } from '@wagmi/core';
+import { getAccount, waitForCallsStatus } from '@wagmi/core';
 import { waitForCallsStatusQueryKey } from 'wagmi/query';
 const ensureCallsStatusFactory = ({
   queryClient: queryClient$1 = queryClient,
   wagmiConfig: wagmiConfig$1 = wagmiConfig,
-  isSafe = false
+  isSafe: _isSafe
 } = {}) => async ({
   id
 }) => {
+  const {
+    connector
+  } = getAccount(wagmiConfig$1);
+  const isConnectorSafe = !!connector && isSafeConnector(connector);
+  const isSafe = _isSafe || isConnectorSafe || !!connector && await isExternalConnectorWithSafeIframe(connector);
   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 CHANGED Viewed

	@@ -1 +1 @@
1	- {"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;;;;"}
1	+ {"version":3,"file":"ensureCallsStatus.js","sources":["../../../src/transactions/queries/ensureCallsStatus.ts"],"sourcesContent":["import { isExternalConnectorWithSafeIframe } from \"@/core/state/externalProviderAtom\";\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 isConnectorSafe = !!connector && isSafeConnector(connector);\n\n const isSafe =\n _isSafe \|\|\n isConnectorSafe \|\|\n (!!connector && (await isExternalConnectorWithSafeIframe(connector)));\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","isConnectorSafe","isSafeConnector","isExternalConnectorWithSafeIframe","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,eAAAA,GAAkB,CAAC,CAACF,SAAAA,IAAaG,gBAAgBH,SAAS,CAAA;AAEhE,EAAA,MAAMH,MAAAA,GACJC,WACAI,eAAAA,IACC,CAAC,CAACF,SAAAA,IAAc,MAAMI,kCAAkCJ,SAAS,CAAA;AAEpE,EAAA,MAAMK,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;;;;"}

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

	@@ -1 +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;~~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"}
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,sBAgDlC,CAAC"}

package/dist/transactions/queries/ensureTxReceipt.js CHANGED Viewed

@@ -7,23 +7,26 @@ 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 { isExternalConnectorWithSafeIframe } from '../../core/state/externalProviderAtom.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);
-  if (connector && isSafeConnector(connector)) {
+  const isConnectorSafe = !!connector && isSafeConnector(connector);
+  const isSafe = _isSafe || isConnectorSafe || !!connector && await isExternalConnectorWithSafeIframe(connector);
+  const timeout = isSafe ? SAFE_CALLS_WAIT_TIMEOUT : void 0;
+  let config = wagmiConfig$1;
+  if (isConnectorSafe) {
     const safeClient = await getConnectorClient(wagmiConfig$1, {
       chainId,
       connector

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

	@@ -1 +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\";\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;;;;"}
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 { isExternalConnectorWithSafeIframe } from \"@/core/state/externalProviderAtom\";\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 isConnectorSafe = !!connector && isSafeConnector(connector);\n const isSafe =\n _isSafe \|\|\n isConnectorSafe \|\|\n (!!connector && (await isExternalConnectorWithSafeIframe(connector)));\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 (isConnectorSafe) {\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","isConnectorSafe","isSafeConnector","isExternalConnectorWithSafeIframe","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,eAAAA,GAAkB,CAAC,CAACF,SAAAA,IAAaG,gBAAgBH,SAAS,CAAA;AAChE,EAAA,MAAMN,MAAAA,GACJC,WACAO,eAAAA,IACC,CAAC,CAACF,SAAAA,IAAc,MAAMI,kCAAkCJ,SAAS,CAAA;AAEpE,EAAA,MAAMK,OAAAA,GAAUX,SAASY,uBAAAA,GAA0BC,MAAAA;AAEnD,EAAA,IAAIC,MAAAA,GAAShB,aAAAA;AAIb,EAAA,IAAIU,eAAAA,EAAiB;AACnB,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;;;;"}

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

@@ -1,7 +1,13 @@
-export declare const finalizeStandoloneTxsEffect: import('jotai').Atom<void> & {
+export declare const finalizeStandaloneTxsEffect: import('jotai').Atom<void> & {
+    effect: import('jotai-effect').Effect;
+};
+export declare const finalizeStandaloneSafeTxsEffect: 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 CHANGED Viewed

	@@ -1 +1 @@
1	- {"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"}
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"}

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

@@ -2,27 +2,61 @@ import { atomEffect } from 'jotai-effect';
 import { allPendingStandaloneTransactionItemsAtom, allPendingBatchTransactionItemsAtom } from '../transactionsAtom.js';
 import { finalizeStandaloneTxAtom, finalizeBatchTxAtom } from '../transactionsActionAtom.js';
 import { transactionLogger } from '../../logger.js';
-import { accountAtom } from '../../../lib/web3/wagmi/external.js';
+import { accountAtom, addressAtom } from '../../../lib/web3/wagmi/external.js';
+import { isSafeConnector } from '../../../hooks/connectors/useIsGnosisSafeConnector.js';
+import { isGnosisSafeTx } from '../../utils.js';
 let hasRunStandaloneEffect = false;
-const finalizeStandoloneTxsEffect = atomEffect((get, set) => {
+const finalizeStandaloneTxsEffect = atomEffect((get, set) => {
   if (hasRunStandaloneEffect) return;
   hasRunStandaloneEffect = true;
-  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom);
+  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom).filter((tx) => !isGnosisSafeTx(tx));
   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 account = get(accountAtom);
-  if (account) {
+  const address = get(addressAtom);
+  if (address) {
     hasRunBatchEffect = true;
-    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom);
+    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom).filter((tx) => !isGnosisSafeTx(tx));
     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 { finalizeBatchTxsEffect, finalizeStandoloneTxsEffect };
+export { finalizeBatchSafeTxsEffect, finalizeBatchTxsEffect, finalizeStandaloneSafeTxsEffect, finalizeStandaloneTxsEffect };
 //# sourceMappingURL=finalize.js.map

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

	@@ -1 +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 } 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;;;;"}
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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"}

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

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

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

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

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

	@@ -1 +1 @@
1	- {"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;;;;"}
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;;;;"}

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

	@@ -1 +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;~~AAsBlB~~,eAAO,MAAM,SAAS;;~~CAoBrB~~,CAAC;AAEF,eAAO,MAAM,wBAAwB;;~~CA0BnC~~,CAAC;AAEH,eAAO,MAAM,mBAAmB;;CA8B9B,CAAC;AAEH,eAAO,MAAM,KAAK,GAAU,aAAa,kBAAkB,kBAE1D,CAAC"}
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;AA0BlB,eAAO,MAAM,SAAS;;CAuBrB,CAAC;AAEF,eAAO,MAAM,wBAAwB;;CAkCnC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;CA8B9B,CAAC;AAEH,eAAO,MAAM,KAAK,GAAU,aAAa,kBAAkB,kBAE1D,CAAC"}