@velora-dex/widget 0.1.0-rc.2 → 0.1.1

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

@@ -0,0 +1,7 @@
+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;
+};
+//# sourceMappingURL=finalize.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,28 @@
+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';
+
+let hasRunStandaloneEffect = false;
+const finalizeStandoloneTxsEffect = atomEffect((get, set) => {
+  if (hasRunStandaloneEffect) return;
+  hasRunStandaloneEffect = true;
+  const pendingStandaloneTxs = get(allPendingStandaloneTransactionItemsAtom);
+  transactionLogger.log("Effect::pendingStandaloneTxs", pendingStandaloneTxs);
+  pendingStandaloneTxs.forEach((tx) => set(finalizeStandaloneTxAtom, tx));
+});
+let hasRunBatchEffect = false;
+const finalizeBatchTxsEffect = atomEffect((get, set) => {
+  if (hasRunBatchEffect) return;
+  const account = get(accountAtom);
+  if (account) {
+    hasRunBatchEffect = true;
+    const pendingBatchTxs = get(allPendingBatchTransactionItemsAtom);
+    transactionLogger.log("Effect::pendingBatchTxs", pendingBatchTxs);
+    pendingBatchTxs.forEach((tx) => set(finalizeBatchTxAtom, tx));
+  }
+});
+
+export { finalizeBatchTxsEffect, finalizeStandoloneTxsEffect };
+//# sourceMappingURL=finalize.js.map

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { useAtom } from 'jotai';
+import { finalizeStandoloneTxsEffect, finalizeBatchTxsEffect } from '../effects/finalize.js';
+
+function useActivateEffects() {
+  useAtom(finalizeStandoloneTxsEffect);
+  useAtom(finalizeBatchTxsEffect);
+}
+
+export { useActivateEffects };
+//# sourceMappingURL=useActivateEffects.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useActivateEffects.js","sources":["../../../../src/transactions/state/hooks/useActivateEffects.ts"],"sourcesContent":["import { useAtom } from \"jotai\";\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,CAAAC,2BAAmC,CAAA;AACnCD,EAAAA,OAAAA,CAAAE,sBAA8B,CAAA;AAAC;;;;"}

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

@@ -0,0 +1,3 @@
+export declare const useUserPendingTransactions: () => import('../../types').TransactionItem[];
+export declare const useUserSwapTransactions: () => import('../../types').TransactionItemSwap[];
+//# sourceMappingURL=useTransactions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTransactions.d.ts","sourceRoot":"","sources":["../../../../src/transactions/state/hooks/useTransactions.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,0BAA0B,+CACI,CAAC;AAC5C,eAAO,MAAM,uBAAuB,mDACI,CAAC"}

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

@@ -0,0 +1,12 @@
+import { useAtomValue } from 'jotai';
+import { userPendingTransactionsAtom, userSwapTransactionsAtom } from '../transactionsAtom.js';
+
+const useUserPendingTransactions = () => {
+  return useAtomValue(userPendingTransactionsAtom);
+};
+const useUserSwapTransactions = () => {
+  return useAtomValue(userSwapTransactionsAtom);
+};
+
+export { useUserPendingTransactions, useUserSwapTransactions };
+//# sourceMappingURL=useTransactions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useTransactions.js","sources":["../../../../src/transactions/state/hooks/useTransactions.ts"],"sourcesContent":["import { useAtomValue } from \"jotai\";\nimport {\n  userPendingTransactionsAtom,\n  userSwapTransactionsAtom,\n} from \"../transactionsAtom\";\n\nexport const useUserPendingTransactions = () =>\n  useAtomValue(userPendingTransactionsAtom);\nexport const useUserSwapTransactions = () =>\n  useAtomValue(userSwapTransactionsAtom);\n"],"names":["useUserPendingTransactions","useAtomValue","userPendingTransactionsAtom","useUserSwapTransactions","userSwapTransactionsAtom"],"mappings":";;;AAMO,MAAMA,6BAA6BA,MAAA;AAAA,EAAA,OACxCC,aAAAC,2BAAwC,CAAA;AAAC;AACpC,MAAMC,0BAA0BA,MAAA;AAAA,EAAA,OACrCF,aAAAG,wBAAqC,CAAA;AAAC;;;;"}

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

@@ -0,0 +1,12 @@
+import { StandaloneTransactionItem, BatchTransactionItem, MinTransactionItem } from '../types';
+export declare const addTxAtom: import('jotai').WritableAtom<null, [transaction: MinTransactionItem], void> & {
+    init: null;
+};
+export declare const finalizeStandaloneTxAtom: import('jotai').WritableAtom<null, [StandaloneTransactionItem], Promise<void>> & {
+    init: null;
+};
+export declare const finalizeBatchTxAtom: import('jotai').WritableAtom<null, [BatchTransactionItem], Promise<void>> & {
+    init: null;
+};
+export declare const addTx: (transaction: MinTransactionItem) => Promise<void>;
+//# sourceMappingURL=transactionsActionAtom.d.ts.map

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

@@ -0,0 +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"}

package/dist/transactions/state/transactionsActionAtom.js

@@ -0,0 +1,122 @@
+import { atom } from 'jotai';
+import { jotaiStore } from '../../core/inputs/state/store.js';
+import { ensureCallsStatusFactory } from '../queries/ensureCallsStatus.js';
+import { ensureTxReceiptFactory } from '../queries/ensureTxReceipt.js';
+import { WaitForTransactionReceiptTimeoutError, TransactionReceiptNotFoundError, WaitForCallsStatusTimeoutError, MethodNotSupportedRpcError } from 'viem';
+import { transactionLogger } from '../logger.js';
+import { transactionsAtom } from './transactionsAtom.js';
+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 account = get(accountAtom);
+  assert(account, "addTxAtom: account is required");
+  const txWithMeta = {
+    ...transaction,
+    account,
+    timestamp: Date.now(),
+    dropped: false
+  };
+  set(transactionsAtom, (current) => assignTx(current, txWithMeta));
+  if (isStandaloneTransactionItem(txWithMeta)) {
+    await set(finalizeStandaloneTxAtom, txWithMeta);
+  } else {
+    await set(finalizeBatchTxAtom, txWithMeta);
+  }
+});
+const finalizeStandaloneTxAtom = atom(null, async (_, set, transaction) => {
+  const finalizedTx = {
+    ...transaction
+  };
+  const ensureTxReceipt = ensureTxReceiptFactory();
+  try {
+    finalizedTx.receipt = await ensureTxReceipt({
+      hash: transaction.transactionHash,
+      chainId: transaction.chainId
+    });
+  } catch (error) {
+    if (error instanceof WaitForTransactionReceiptTimeoutError || error instanceof TransactionReceiptNotFoundError) {
+      finalizedTx.dropped = true;
+      transactionLogger.error(`finalizeStandaloneTxAtom::Transaction ${transaction.transactionHash} dropped with error: ${error.message}`);
+    } else throw error;
+  } finally {
+    set(transactionsAtom, (current) => assignTx(current, finalizedTx));
+  }
+});
+const finalizeBatchTxAtom = atom(null, async (_, set, transaction) => {
+  const finalizedTx = {
+    ...transaction
+  };
+  const ensureCallsStatus = ensureCallsStatusFactory();
+  try {
+    const {
+      receipts,
+      status
+    } = await ensureCallsStatus({
+      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(`finalizeBatchTxAtom::Batch transaction ${transaction.callsId} dropped with error: ${error.message}`);
+    } else {
+      finalizedTx.callsStatus = "failure";
+      throw error;
+    }
+  } finally {
+    set(transactionsAtom, (current) => assignTx(current, finalizedTx));
+  }
+});
+const addTx = async (transaction) => {
+  return jotaiStore.set(addTxAtom, transaction);
+};
+function sanitizeTx(tx) {
+  if (isBatchTransactionItem(tx)) {
+    return {
+      action: tx.action,
+      account: tx.account,
+      chainId: tx.chainId,
+      callsId: tx.callsId,
+      callsStatus: tx.callsStatus,
+      timestamp: tx.timestamp,
+      dropped: tx.dropped,
+      receipt: tx.receipt,
+      transactionSpecificData: tx.transactionSpecificData
+    };
+  }
+  return {
+    action: tx.action,
+    chainId: tx.chainId,
+    account: tx.account,
+    transactionHash: tx.transactionHash,
+    timestamp: tx.timestamp,
+    dropped: tx.dropped,
+    receipt: tx.receipt,
+    transactionSpecificData: tx.transactionSpecificData
+  };
+}
+function assignTx(currentTransactions, transaction) {
+  transactionLogger.log("assignTx", {
+    account: transaction.account,
+    transaction
+  });
+  const accountTransactions = currentTransactions[transaction.account] || {};
+  const identifier = isStandaloneTransactionItem(transaction) ? transaction.transactionHash : transaction.callsId;
+  const updatedAccountTransactions = {
+    ...accountTransactions,
+    [identifier]: sanitizeTx({
+      ...accountTransactions[identifier],
+      ...transaction
+    })
+  };
+  return {
+    ...currentTransactions,
+    [transaction.account]: updatedAccountTransactions
+  };
+}
+
+export { addTx, addTxAtom, finalizeBatchTxAtom, finalizeStandaloneTxAtom };
+//# sourceMappingURL=transactionsActionAtom.js.map

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

@@ -0,0 +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/inputs/state/store\";\n\nimport { ensureCallsStatusFactory } from \"../queries/ensureCallsStatus\";\nimport { ensureTxReceiptFactory } from \"../queries/ensureTxReceipt\";\nimport {\n  WaitForCallsStatusTimeoutError,\n  TransactionReceiptNotFoundError,\n  WaitForTransactionReceiptTimeoutError,\n  MethodNotSupportedRpcError,\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      error instanceof WaitForTransactionReceiptTimeoutError ||\n      error instanceof TransactionReceiptNotFoundError\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","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":"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"}

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

@@ -0,0 +1,14 @@
+import { BatchTransactionItem, StandaloneTransactionItem, TransactionItem, TransactionItemSwap } from '../types';
+import { Address } from 'viem';
+export type TransactionsMap = Record<string, TransactionItem>;
+export type TransactionsState = Record<Address, TransactionsMap>;
+export declare const transactionsAtom: import('jotai').WritableAtom<TransactionsState, [typeof import('jotai/utils').RESET | TransactionsState | ((prev: TransactionsState) => typeof import('jotai/utils').RESET | TransactionsState)], void>;
+export declare const allTransactionsAtom: import('jotai').Atom<TransactionItem[]>;
+export declare const userTransactionsAtom: import('jotai').Atom<TransactionItem[]>;
+export declare const allStandaloneTransactionItemsAtom: import('jotai').Atom<StandaloneTransactionItem[]>;
+export declare const allBatchTransactionItemsAtom: import('jotai').Atom<BatchTransactionItem[]>;
+export declare const allPendingStandaloneTransactionItemsAtom: import('jotai').Atom<StandaloneTransactionItem[]>;
+export declare const allPendingBatchTransactionItemsAtom: import('jotai').Atom<BatchTransactionItem[]>;
+export declare const userPendingTransactionsAtom: import('jotai').Atom<TransactionItem[]>;
+export declare const userSwapTransactionsAtom: import('jotai').Atom<TransactionItemSwap[]>;
+//# sourceMappingURL=transactionsAtom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactionsAtom.d.ts","sourceRoot":"","sources":["../../../src/transactions/state/transactionsAtom.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,oBAAoB,EACpB,yBAAyB,EACzB,eAAe,EACf,mBAAmB,EACpB,MAAM,UAAU,CAAC;AAWlB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAKpC,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;AAE9D,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;AAEjE,eAAO,MAAM,gBAAgB,yMAW5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,yCAG9B,CAAC;AAEH,eAAO,MAAM,oBAAoB,yCAM/B,CAAC;AAEH,eAAO,MAAM,iCAAiC,mDAK5C,CAAC;AAEH,eAAO,MAAM,4BAA4B,8CAKxC,CAAC;AAEF,eAAO,MAAM,wCAAwC,mDAKnD,CAAC;AAEH,eAAO,MAAM,mCAAmC,8CAK/C,CAAC;AAEF,eAAO,MAAM,2BAA2B,yCAGtC,CAAC;AAEH,eAAO,MAAM,wBAAwB,6CAGnC,CAAC"}

package/dist/transactions/state/transactionsAtom.js

@@ -0,0 +1,54 @@
+import { atomWithStorage, createJSONStorage } from 'jotai/utils';
+import { atom } from 'jotai';
+import { extractPendingTransactions, isStandaloneTransactionItem, isBatchTransactionItem, extractSwapTransactions } from '../utils.js';
+import { serialize, deserialize } from 'wagmi';
+import { accountAtom } from '../../lib/web3/wagmi/external.js';
+import { emptyArray } from '../../lib/constants/index.js';
+
+const transactionsAtom = atomWithStorage("velora_widget_transactions", {}, createJSONStorage(() => localStorage, {
+  // serialize/deserialize to handle bigint values
+  replacer: (_, value) => serialize(value),
+  reviver: (_, value) => {
+    return typeof value === "string" ? deserialize(value) : value;
+  }
+}), {
+  getOnInit: true
+});
+const allTransactionsAtom = atom((get) => {
+  const transactions = get(transactionsAtom);
+  return Object.values(transactions).flatMap((txMap) => Object.values(txMap));
+});
+const userTransactionsAtom = atom((get) => {
+  const account = get(accountAtom);
+  if (!account) return emptyArray;
+  const transactions = get(transactionsAtom)[account];
+  if (!transactions) return emptyArray;
+  return Object.values(transactions);
+});
+const allStandaloneTransactionItemsAtom = atom((get) => {
+  const transactions = get(allTransactionsAtom);
+  return transactions.filter(isStandaloneTransactionItem);
+});
+const allBatchTransactionItemsAtom = atom((get) => {
+  const transactions = get(allTransactionsAtom);
+  return transactions.filter(isBatchTransactionItem);
+});
+const allPendingStandaloneTransactionItemsAtom = atom((get) => {
+  const transactions = get(allStandaloneTransactionItemsAtom);
+  return extractPendingTransactions(transactions);
+});
+const allPendingBatchTransactionItemsAtom = atom((get) => {
+  const transactions = get(allBatchTransactionItemsAtom);
+  return extractPendingTransactions(transactions);
+});
+const userPendingTransactionsAtom = atom((get) => {
+  const transactions = get(userTransactionsAtom);
+  return extractPendingTransactions(transactions);
+});
+const userSwapTransactionsAtom = atom((get) => {
+  const transactions = get(userTransactionsAtom);
+  return extractSwapTransactions(transactions);
+});
+
+export { allBatchTransactionItemsAtom, allPendingBatchTransactionItemsAtom, allPendingStandaloneTransactionItemsAtom, allStandaloneTransactionItemsAtom, allTransactionsAtom, transactionsAtom, userPendingTransactionsAtom, userSwapTransactionsAtom, userTransactionsAtom };
+//# sourceMappingURL=transactionsAtom.js.map

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

@@ -0,0 +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 { accountAtom } from \"@/lib/web3/wagmi/external\";\nimport { emptyArray } from \"@/lib/constants\";\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  \"velora_widget_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","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":";;;;;;;AAyBO,MAAMA,mBAAmBC,eAAAA,CAC9B,4BAAA,EACA,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,IAAIb,gBAAgB,CAAA;AACzC,EAAA,OAAOe,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,CAAIb,gBAAgB,CAAA,CAAEoB,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;;;;"}

package/dist/transactions/status.d.ts

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

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

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

package/dist/transactions/status.js

@@ -0,0 +1,7 @@
+function getTxStatus(tx) {
+  if (tx.action === "swap" && tx.transactionSpecificData.source === "metabase") return "success";
+  return tx.receipt?.status || "pending";
+}
+
+export { getTxStatus };
+//# sourceMappingURL=status.js.map

package/dist/transactions/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sources":["../../src/transactions/status.ts"],"sourcesContent":["import type { TransactionReceipt } from \"viem\";\nimport type { TransactionItem } from \"./types\";\n\nexport type TxStatus = TransactionReceipt[\"status\"] | \"pending\";\n\nexport function getTxStatus(tx: TransactionItem): TxStatus {\n  if (tx.action === \"swap\" && tx.transactionSpecificData.source === \"metabase\")\n    return \"success\";\n\n  return tx.receipt?.status || \"pending\";\n}\n"],"names":["getTxStatus","tx","action","transactionSpecificData","source","receipt","status"],"mappings":"AAKO,SAASA,YAAYC,EAAAA,EAA+B;AACzD,EAAA,IAAIA,GAAGC,MAAAA,KAAW,MAAA,IAAUD,GAAGE,uBAAAA,CAAwBC,MAAAA,KAAW,YAChE,OAAO,SAAA;AAET,EAAA,OAAOH,EAAAA,CAAGI,SAASC,MAAAA,IAAU,SAAA;AAC/B;;;;"}

package/dist/transactions/types.d.ts

@@ -0,0 +1,71 @@
+import { CallsReceipt } from '../hooks/batch/useAwaitCalls';
+import { SupportedChainId } from '../lib/web3/wagmi/types';
+import { OrderData } from '@velora-dex/sdk';
+import { Address, Hash, Prettify, TransactionReceipt } from 'viem';
+export type TransactionCommonData = {
+    chainId: SupportedChainId;
+    timestamp: number;
+    account: Address;
+    dropped: boolean;
+};
+export interface StandaloneTransactionItemData extends TransactionCommonData {
+    transactionHash: Hash;
+    receipt?: TransactionReceipt;
+}
+export interface BatchTransactionItemData extends TransactionCommonData {
+    callsId: string;
+    callsStatus?: "pending" | "success" | "failure";
+    receipt?: CallsReceipt;
+}
+export type TransactionItemBase = StandaloneTransactionItemData | BatchTransactionItemData;
+export type TransactionItemSwap = TransactionItemBase & {
+    action: "swap";
+    transactionSpecificData: {
+        action: "swap";
+        source: "local" | "metabase";
+        srcTokenAddress: Address;
+        destTokenAddress: Address;
+        srcAmount: string;
+        destAmount: string;
+        srcAmountUSD: string | null;
+        destAmountUSD: string | null;
+        gasCost: string;
+        gasCostUSD?: string;
+    };
+};
+export type TransactionItemApprove = TransactionItemBase & {
+    action: "approve";
+    transactionSpecificData: {
+        action: "approve";
+        approvedAmount: bigint;
+        tokenAddress: Address;
+        spenderAddress: Address;
+    };
+};
+export type TransactionItemWrapEth = TransactionItemBase & {
+    action: "wrapETH";
+    transactionSpecificData: {
+        action: "wrapETH";
+        wrappedAmount: bigint;
+    };
+};
+export type TransactionItemFillOtcOrder = TransactionItemBase & {
+    action: "fillOtcOrder";
+    transactionSpecificData: {
+        action: "fillOtcOrder";
+        filledOrder: OrderData;
+    };
+};
+export type TransactionItemCancelOtcOrder = TransactionItemBase & {
+    action: "cancelOtcOrder";
+    transactionSpecificData: {
+        action: "cancelOtcOrder";
+        cancelledOrder: OrderData;
+    };
+};
+export type TransactionItem = TransactionItemSwap | TransactionItemApprove | TransactionItemWrapEth | TransactionItemFillOtcOrder | TransactionItemCancelOtcOrder;
+export type MinTransactionItem = TransactionWithoutMeta<TransactionItem>;
+export type StandaloneTransactionItem = Prettify<Extract<TransactionItem, StandaloneTransactionItemData>>;
+export type BatchTransactionItem = Prettify<Extract<TransactionItem, BatchTransactionItemData>>;
+export type TransactionWithoutMeta<T> = T extends Pick<TransactionItem, "dropped" | "timestamp" | "account"> ? Prettify<Omit<T, "dropped" | "timestamp" | "account">> : T;
+//# sourceMappingURL=types.d.ts.map

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

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

package/dist/transactions/utils.d.ts

@@ -0,0 +1,11 @@
+import { Hash } from 'viem';
+import { BatchTransactionItem, StandaloneTransactionItem, TransactionItem, TransactionItemSwap } from './types';
+export declare function isStandaloneTransactionItem(item: TransactionItem): item is StandaloneTransactionItem;
+export declare function isBatchTransactionItem(item: TransactionItem): item is BatchTransactionItem;
+export declare function extractPendingTransactions<T extends StandaloneTransactionItem | BatchTransactionItem>(transactions: T[]): T[];
+export declare function extractSwapTransactions(transactions: (StandaloneTransactionItem | BatchTransactionItem)[]): TransactionItemSwap[];
+export type TransactionItemSwapWithId = TransactionItemSwap & {
+    id: Hash;
+};
+export declare function combineSwapTransactionItems<T extends TransactionItemSwap>(...txArrays: T[][]): TransactionItemSwapWithId[];
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/transactions/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AACjC,OAAO,KAAK,EACV,oBAAoB,EACpB,yBAAyB,EACzB,eAAe,EACf,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,GACpB,IAAI,IAAI,yBAAyB,CAEnC;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,eAAe,GACpB,IAAI,IAAI,oBAAoB,CAE9B;AAED,wBAAgB,0BAA0B,CACxC,CAAC,SAAS,yBAAyB,GAAG,oBAAoB,EAC1D,YAAY,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAQxB;AAED,wBAAgB,uBAAuB,CACrC,YAAY,EAAE,CAAC,yBAAyB,GAAG,oBAAoB,CAAC,EAAE,GACjE,mBAAmB,EAAE,CAEvB;AAID,MAAM,MAAM,yBAAyB,GAAG,mBAAmB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC;AAE3E,wBAAgB,2BAA2B,CAAC,CAAC,SAAS,mBAAmB,EACvE,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,GACjB,yBAAyB,EAAE,CAiB7B"}

package/dist/transactions/utils.js

@@ -0,0 +1,26 @@
+function isStandaloneTransactionItem(item) {
+  return "transactionHash" in item;
+}
+function isBatchTransactionItem(item) {
+  return "callsId" in item;
+}
+function extractPendingTransactions(transactions) {
+  return transactions.filter((tx) => !tx.dropped && (isStandaloneTransactionItem(tx) ? !tx.receipt : !tx.callsStatus || tx.callsStatus === "pending"));
+}
+function extractSwapTransactions(transactions) {
+  return transactions.filter((tx) => tx.action === "swap");
+}
+function combineSwapTransactionItems(...txArrays) {
+  const map = {};
+  txArrays.flat().forEach((item) => {
+    const transactionHash = isStandaloneTransactionItem(item) ? item.transactionHash : item.receipt?.transactionHash;
+    if (transactionHash) map[transactionHash] = {
+      ...item,
+      id: transactionHash
+    };
+  });
+  return Object.values(map);
+}
+
+export { combineSwapTransactionItems, extractPendingTransactions, extractSwapTransactions, isBatchTransactionItem, isStandaloneTransactionItem };
+//# sourceMappingURL=utils.js.map

package/dist/transactions/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../src/transactions/utils.ts"],"sourcesContent":["import type { Hash } from \"viem\";\nimport type {\n  BatchTransactionItem,\n  StandaloneTransactionItem,\n  TransactionItem,\n  TransactionItemSwap,\n} from \"./types\";\n\nexport function isStandaloneTransactionItem(\n  item: TransactionItem\n): item is StandaloneTransactionItem {\n  return \"transactionHash\" in item;\n}\n\nexport function isBatchTransactionItem(\n  item: TransactionItem\n): item is BatchTransactionItem {\n  return \"callsId\" in item;\n}\n\nexport function extractPendingTransactions<\n  T extends StandaloneTransactionItem | BatchTransactionItem,\n>(transactions: T[]): T[] {\n  return transactions.filter(\n    (tx) =>\n      !tx.dropped &&\n      (isStandaloneTransactionItem(tx)\n        ? !tx.receipt\n        : !tx.callsStatus || tx.callsStatus === \"pending\")\n  );\n}\n\nexport function extractSwapTransactions(\n  transactions: (StandaloneTransactionItem | BatchTransactionItem)[]\n): TransactionItemSwap[] {\n  return transactions.filter((tx) => tx.action === \"swap\");\n}\n\n// not all TransactionItemSwap have transactionHash\n// id will be either transactionHash (for standalone tx) or receipt.transactionHash (for batch tx)\nexport type TransactionItemSwapWithId = TransactionItemSwap & { id: Hash };\n\nexport function combineSwapTransactionItems<T extends TransactionItemSwap>(\n  ...txArrays: T[][]\n): TransactionItemSwapWithId[] {\n  const map: Record<Hash, TransactionItemSwapWithId> = {};\n\n  txArrays.flat().forEach((item) => {\n    const transactionHash = isStandaloneTransactionItem(item)\n      ? item.transactionHash\n      : item.receipt?.transactionHash;\n\n    // we can't rely on callsId for batch swap tx as identifier if we have another source of truth\n    // better to not show pending calls until we have transactionHash\n    // otherwise it may lead to duplicate entries in the Activities list\n    // when transaction appeared in the metabase but we still have pending call in the local storage\n    if (transactionHash)\n      map[transactionHash] = { ...item, id: transactionHash };\n  });\n\n  return Object.values(map);\n}\n"],"names":["isStandaloneTransactionItem","item","isBatchTransactionItem","extractPendingTransactions","transactions","filter","tx","dropped","receipt","callsStatus","extractSwapTransactions","action","combineSwapTransactionItems","txArrays","map","flat","forEach","transactionHash","id","Object","values"],"mappings":"AAQO,SAASA,4BACdC,IAAAA,EACmC;AACnC,EAAA,OAAO,iBAAA,IAAqBA,IAAAA;AAC9B;AAEO,SAASC,uBACdD,IAAAA,EAC8B;AAC9B,EAAA,OAAO,SAAA,IAAaA,IAAAA;AACtB;AAEO,SAASE,2BAEdC,YAAAA,EAAwB;AACxB,EAAA,OAAOA,aAAaC,MAAAA,CACjBC,CAAAA,EAAAA,KACC,CAACA,EAAAA,CAAGC,YACHP,2BAAAA,CAA4BM,EAAE,CAAA,GAC3B,CAACA,GAAGE,OAAAA,GACJ,CAACF,GAAGG,WAAAA,IAAeH,EAAAA,CAAGG,gBAAgB,SAAA,CAC9C,CAAA;AACF;AAEO,SAASC,wBACdN,YAAAA,EACuB;AACvB,EAAA,OAAOA,YAAAA,CAAaC,MAAAA,CAAQC,CAAAA,EAAAA,KAAOA,EAAAA,CAAGK,WAAW,MAAM,CAAA;AACzD;AAMO,SAASC,+BACXC,QAAAA,EAC0B;AAC7B,EAAA,MAAMC,MAA+C,EAAC;AAEtDD,EAAAA,QAAAA,CAASE,IAAAA,EAAK,CAAEC,OAAAA,CAASf,CAAAA,IAAAA,KAAS;AAChC,IAAA,MAAMgB,kBAAkBjB,2BAAAA,CAA4BC,IAAI,IACpDA,IAAAA,CAAKgB,eAAAA,GACLhB,KAAKO,OAAAA,EAASS,eAAAA;AAMlB,IAAA,IAAIA,eAAAA,EACFH,GAAAA,CAAIG,eAAe,CAAA,GAAI;AAAA,MAAE,GAAGhB,IAAAA;AAAAA,MAAMiB,EAAAA,EAAID;AAAAA,KAAgB;AAAA,EAC1D,CAAC,CAAA;AAED,EAAA,OAAOE,MAAAA,CAAOC,OAAON,GAAG,CAAA;AAC1B;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@velora-dex/widget",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.1",
   "license": "MIT",
   "type": "module",
   "files": [
@@ -67,22 +67,25 @@
     "@radix-ui/react-select": "^2.2.5",
     "@radix-ui/react-slot": "^1.2.3",
     "@radix-ui/react-switch": "^1.2.5",
+    "@radix-ui/react-tabs": "^1.1.13",
     "@radix-ui/react-tooltip": "^1.2.7",
     "@tanstack/react-pacer": "^0.14.0",
     "@tanstack/react-query": "^5.84.1",
     "@tanstack/react-query-devtools": "^5.84.1",
     "@tanstack/react-virtual": "^3.13.12",
     "@uniswap/token-lists": "1.0.0-beta.34",
-    "@velora-dex/sdk": "8.1.1-dev.1",
+    "@velora-dex/sdk": "^9.1.0",
     "@wagmi/core": "^2.18.1",
     "axios": "^1.11.0",
     "big.js": "^7.0.1",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "copy-to-clipboard": "^3.3.3",
+    "dayjs": "^1.11.18",
     "immer": "^10.1.1",
-    "jotai": "^2.13.0",
-    "jotai-devtools": "^0.12.0",
+    "jotai": "^2.15.0",
+    "jotai-devtools": "^0.13.0",
+    "jotai-effect": "^2.1.3",
     "jotai-immer": "^0.4.1",
     "lucide-react": "^0.536.0",
     "react-compiler-runtime": "19.1.0-rc.2",
@@ -99,4 +102,4 @@
     "react": "^18.x || ^19.x",
     "react-dom": "^18.x || ^19.x"
   }
-}
+}

package/dist/components/ui/badge.js

@@ -1,71 +0,0 @@
-import { jsx } from 'react/jsx-runtime';
-import { d as distExports } from '../../_virtual/index.js';
-import { Slot } from '@radix-ui/react-slot';
-import { cva } from 'class-variance-authority';
-import { cn } from '../../lib/utils/index.js';
-
-const badgeVariants = cva("inline-flex items-center justify-center rounded-md border px-2 py-0.5 text-xs font-medium w-fit whitespace-nowrap shrink-0 [&>svg]:size-3 gap-1 [&>svg]:pointer-events-none focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive transition-[color,box-shadow] overflow-hidden", {
-  variants: {
-    variant: {
-      default: "border-transparent bg-primary text-primary-foreground [a&]:hover:bg-primary/90",
-      secondary: "border-transparent bg-secondary text-secondary-foreground [a&]:hover:bg-secondary/90",
-      destructive: "border-transparent bg-destructive text-white [a&]:hover:bg-destructive/90 focus-visible:ring-destructive/20 dark:focus-visible:ring-destructive/40 dark:bg-destructive/60",
-      outline: "text-foreground [a&]:hover:bg-accent [a&]:hover:text-accent-foreground"
-    }
-  },
-  defaultVariants: {
-    variant: "default"
-  }
-});
-function Badge(t0) {
-  const $ = distExports.c(12);
-  let className;
-  let props;
-  let t1;
-  let variant;
-  if ($[0] !== t0) {
-    ({
-      className,
-      variant,
-      asChild: t1,
-      ...props
-    } = t0);
-    $[0] = t0;
-    $[1] = className;
-    $[2] = props;
-    $[3] = t1;
-    $[4] = variant;
-  } else {
-    className = $[1];
-    props = $[2];
-    t1 = $[3];
-    variant = $[4];
-  }
-  const asChild = t1 === void 0 ? false : t1;
-  const Comp = asChild ? Slot : "span";
-  let t2;
-  if ($[5] !== className || $[6] !== variant) {
-    t2 = cn(badgeVariants({
-      variant
-    }), className);
-    $[5] = className;
-    $[6] = variant;
-    $[7] = t2;
-  } else {
-    t2 = $[7];
-  }
-  let t3;
-  if ($[8] !== Comp || $[9] !== props || $[10] !== t2) {
-    t3 = /* @__PURE__ */ jsx(Comp, { "data-slot": "badge", className: t2, ...props });
-    $[8] = Comp;
-    $[9] = props;
-    $[10] = t2;
-    $[11] = t3;
-  } else {
-    t3 = $[11];
-  }
-  return t3;
-}
-
-export { Badge };
-//# sourceMappingURL=badge.js.map