getting liquidity from both networks and saving it at store. splitting methods.ts into 2 different files: buyerMethods.ts and sellerMethods.ts

src/blockchain/buyerMethods.ts

@@ -1,52 +1,12 @@
 import { useEtherStore } from "@/store/ether";
 
 import { getProvider } from "./provider";
-import { getTokenAddress, getP2PixAddress } from "./addresses";
+import { getP2PixAddress } from "./addresses";
 
 import p2pix from "../utils/smart_contract_files/P2PIX.json";
-import mockToken from "../utils/smart_contract_files/MockToken.json";
 
 import { BigNumber, ethers, type Event } from "ethers";
-import { formatEther, parseEther } from "ethers/lib/utils";
-
-const addDeposit = async (tokenQty: string, pixKey: string) => {
-  const provider = getProvider();
-
-  const signer = provider.getSigner();
-  const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
-
-  const deposit = await p2pContract.deposit(
-    getTokenAddress(),
-    parseEther(tokenQty),
-    pixKey,
-    ethers.utils.formatBytes32String("")
-  );
-  await deposit.wait();
-
-  // await updateWalletStatus();
-  // await updateDepositAddedEvents();
-  // await updateValidDeposits();
-};
-
-const approveTokens = async (tokenQty: string) => {
-  const provider = getProvider();
-
-  const signer = provider.getSigner();
-
-  const tokenContract = new ethers.Contract(
-    getTokenAddress(),
-    mockToken.abi,
-    signer
-  );
-
-  const apprv = await tokenContract.approve(
-    getP2PixAddress(),
-    parseEther(tokenQty)
-  );
-
-  await apprv.wait();
-  return apprv;
-};
+import { formatEther } from "ethers/lib/utils";
 
 const cancelDeposit = async (depositId: BigNumber): Promise<Boolean> => {
   const provider = getProvider();
@@ -55,7 +15,7 @@ const cancelDeposit = async (depositId: BigNumber): Promise<Boolean> => {
   const contract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
   await contract.cancelDeposit(depositId);
 
-  // // await updateWalletBalance();
+  // await updateWalletBalance();
   // await updateValidDeposits();
   return true;
 };
@@ -149,11 +109,4 @@ const releaseLock = async (
   return release;
 };
 
-export {
-  approveTokens,
-  addDeposit,
-  cancelDeposit,
-  withdrawDeposit,
-  addLock,
-  releaseLock,
-};
+export { cancelDeposit, withdrawDeposit, addLock, releaseLock };

src/blockchain/events.ts

@@ -1 +1,136 @@
-export {};
+import { useEtherStore } from "@/store/ether";
+import { ethers } from "ethers";
+
+import { getProvider } from "./provider";
+import { mapDeposits } from "./sellerMethods";
+import { getP2PixAddress } from "./addresses";
+
+import p2pix from "../utils/smart_contract_files/P2PIX.json";
+import { formatEther } from "ethers/lib/utils";
+
+const getNetworksLiquidity = async () => {
+  console.log("Loading events");
+
+  const goerliProvider = new ethers.providers.JsonRpcProvider(
+    import.meta.env.VITE_GOERLI_API_URL,
+    5
+  ); // goerli provider
+  const mumbaiProvider = new ethers.providers.JsonRpcProvider(
+    import.meta.env.VITE_MUMBAI_API_URL,
+    80001
+  ); // mumbai provider
+
+  const p2pContractGoerli = new ethers.Contract(
+    "0x5f3EFA9A90532914545CEf527C530658af87e196",
+    p2pix.abi,
+    goerliProvider
+  );
+  const p2pContractMumbai = new ethers.Contract(
+    "0x5f3EFA9A90532914545CEf527C530658af87e196",
+    p2pix.abi,
+    mumbaiProvider
+  );
+
+  const filterDepositsGoerli = p2pContractGoerli.filters.DepositAdded(null);
+  const eventsDepositsGoerli = await p2pContractGoerli.queryFilter(
+    filterDepositsGoerli
+  );
+
+  const filterDepositsMumbai = p2pContractMumbai.filters.DepositAdded(null);
+  const eventsDepositsMumbai = await p2pContractMumbai.queryFilter(
+    filterDepositsMumbai
+  );
+
+  const depositListGoerli: any[] = await Promise.all(
+    eventsDepositsGoerli
+      .map(async (deposit) => {
+        const mappedDeposit = await p2pContractGoerli.mapDeposits(
+          deposit.args?.depositID
+        );
+        let validDepositGoerli = {};
+
+        if (mappedDeposit.valid) {
+          validDepositGoerli = {
+            blockNumber: deposit.blockNumber,
+            depositID: deposit.args?.depositID,
+            remaining: formatEther(mappedDeposit.remaining),
+            seller: mappedDeposit.seller,
+            pixKey: mappedDeposit.pixTarget,
+          };
+        }
+
+        return validDepositGoerli;
+      })
+      .filter((deposit) => deposit)
+  );
+
+  const depositListMumbai: any[] = await Promise.all(
+    eventsDepositsMumbai
+      .map(async (deposit) => {
+        const mappedDeposit = await p2pContractMumbai.mapDeposits(
+          deposit.args?.depositID
+        );
+        let validDepositMumbai = {};
+
+        if (mappedDeposit.valid) {
+          validDepositMumbai = {
+            blockNumber: deposit.blockNumber,
+            depositID: deposit.args?.depositID,
+            remaining: formatEther(mappedDeposit.remaining),
+            seller: mappedDeposit.seller,
+            pixKey: mappedDeposit.pixTarget,
+          };
+        }
+
+        return validDepositMumbai;
+      })
+      .filter((deposit) => deposit)
+  );
+
+  const etherStore = useEtherStore();
+
+  etherStore.setDepositsValidListGoerli(depositListGoerli);
+  console.log(depositListGoerli);
+
+  etherStore.setDepositsValidListMumbai(depositListMumbai);
+  console.log(depositListMumbai);
+};
+
+const getValidDeposits = async (): Promise<any[] | undefined> => {
+  const provider = getProvider();
+  const signer = provider.getSigner();
+
+  const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
+
+  const filterDeposits = p2pContract.filters.DepositAdded(null);
+  const eventsDeposits = await p2pContract.queryFilter(filterDeposits);
+
+  const depositList: any[] = await Promise.all(
+    eventsDeposits
+      .map(async (deposit) => {
+        const mappedDeposit = await mapDeposits(deposit.args?.depositID);
+        let validDeposit = {};
+
+        if (mappedDeposit.valid) {
+          validDeposit = {
+            blockNumber: deposit.blockNumber,
+            depositID: deposit.args?.depositID,
+            remaining: formatEther(mappedDeposit.remaining),
+            seller: mappedDeposit.seller,
+            pixKey: mappedDeposit.pixTarget,
+          };
+        }
+
+        return validDeposit;
+      })
+      .filter((deposit) => deposit)
+  );
+
+  // const etherStore = useEtherStore();
+  // etherStore.setDepositsValidList(depositList);
+  // console.log(depositList)
+
+  return depositList;
+};
+
+export { getValidDeposits, getNetworksLiquidity };

src/blockchain/sellerMethods.ts

@@ -0,0 +1,65 @@
+import { getProvider } from "./provider";
+import { updateWalletStatus } from "./wallet";
+import { getTokenAddress, getP2PixAddress } from "./addresses";
+import { parseEther } from "ethers/lib/utils";
+
+import { BigNumber, ethers } from "ethers";
+
+import p2pix from "../utils/smart_contract_files/P2PIX.json";
+import mockToken from "../utils/smart_contract_files/MockToken.json";
+
+// Seller Flow methods //
+
+// Approve Tokens
+const approveTokens = async (tokenQty: string) => {
+  const provider = getProvider();
+  const signer = provider.getSigner();
+
+  const tokenContract = new ethers.Contract(
+    getTokenAddress(),
+    mockToken.abi,
+    signer
+  );
+
+  const apprv = await tokenContract.approve(
+    getP2PixAddress(),
+    parseEther(tokenQty)
+  );
+
+  await apprv.wait();
+  return apprv;
+};
+
+// Add deposit
+const addDeposit = async (tokenQty: string, pixKey: string) => {
+  const provider = getProvider();
+
+  const signer = provider.getSigner();
+  const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
+
+  const deposit = await p2pContract.deposit(
+    getTokenAddress(),
+    parseEther(tokenQty),
+    pixKey,
+    ethers.utils.formatBytes32String("")
+  );
+
+  await deposit.wait();
+
+  await updateWalletStatus();
+  // await updateDepositAddedEvents();
+  // await updateValidDeposits();
+};
+
+// Map deposit
+const mapDeposits = async (depositId: BigNumber): Promise<any> => {
+  const provider = getProvider();
+
+  const signer = provider.getSigner();
+  const contract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
+  const deposit = await contract.mapDeposits(depositId);
+
+  return deposit;
+};
+
+export { approveTokens, addDeposit, mapDeposits };