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 };

src/components/SearchComponent.vue

@@ -9,7 +9,7 @@ import { connectProvider } from "@/blockchain/provider";
 // Store reference
 const etherStore = useEtherStore();
 
-const { walletAddress, depositsValidList } = storeToRefs(etherStore);
+const { walletAddress, depositsValidListGoerli } = storeToRefs(etherStore);
 
 // Reactive state
 const tokenValue = ref(0);
@@ -59,7 +59,7 @@ const verifyLiquidity = () => {
   selectedDeposit.value = null;
   if (!walletAddress.value || tokenValue.value <= 0) return;
 
-  depositsValidList.value.find((element) => {
+  depositsValidListGoerli.value.find((element) => {
     const remaining = element.remaining;
     if (
       tokenValue.value!! <= remaining &&

src/store/ether.ts

@@ -8,8 +8,10 @@ export const useEtherStore = defineStore("ether", {
     networkName: NetworkEnum.ethereum,
     loadingLock: false,
     sellerView: false,
-    // Depósitos válidos para compra
-    depositsValidList: [] as any[],
+    // Depósitos válidos para compra GOERLI
+    depositsValidListGoerli: [] as any[],
+    // Depósitos válidos para compra MUMBAI
+    depositsValidListMumbai: [] as any[],
     // Depósitos adicionados na blockchain
     depositsAddedList: [] as any[],
     // Depósitos expirados na blockchain
@@ -37,8 +39,11 @@ export const useEtherStore = defineStore("ether", {
     setSellerView(sellerView: boolean) {
       this.sellerView = sellerView;
     },
-    setDepositsValidList(depositsValidList: any[]) {
-      this.depositsValidList = depositsValidList;
+    setDepositsValidListGoerli(depositsValidList: any[]) {
+      this.depositsValidListGoerli = depositsValidList;
+    },
+    setDepositsValidListMumbai(depositsValidList: any[]) {
+      this.depositsValidListMumbai = depositsValidList;
     },
     setDepositsAddedList(depositsAddedList: any[]) {
       this.depositsAddedList = depositsAddedList;
@@ -56,10 +61,11 @@ export const useEtherStore = defineStore("ether", {
       this.locksExpiredList = locksExpiredList;
     },
   },
+  // Alterar para integrar com mumbai
   getters: {
     getValidDepositByWalletAddress: (state) => {
       return (walletAddress: string) =>
-        state.depositsValidList
+        state.depositsValidListGoerli
           .filter((deposit) => deposit.seller == walletAddress)
           .sort((a, b) => {
             return b.blockNumber - a.blockNumber;

src/utils/blockchain.ts

@@ -106,45 +106,6 @@ const listReleaseTransactionByWalletAddress = async (
   });
 };
 
-//get valid deposits
-const getValidDeposits = async (): Promise<any[] | undefined> => {
-  const window_ = window as any;
-  const connection = window_.ethereum;
-  let provider: ethers.providers.Web3Provider | null = null;
-
-  if (!connection) return [];
-
-  provider = new ethers.providers.Web3Provider(connection);
-  const signer = provider.getSigner();
-  const p2pContract = new ethers.Contract(addresses.p2pix, 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: formatBigNumber(mappedDeposit.remaining),
-            seller: mappedDeposit.seller,
-            pixKey: mappedDeposit.pixTarget,
-          };
-        }
-
-        return validDeposit;
-      })
-      .filter((deposit) => deposit)
-  );
-
-  return depositList;
-};
-
 // Update events at store methods
 const updateValidDeposits = async () => {
   const etherStore = useEtherStore();
@@ -207,19 +168,6 @@ const updateLockReleasedEvents = async () => {
   console.log("RELEASES", eventsReleases);
 };
 
-// Get specific deposit data by its ID
-const mapDeposits = async (depositId: BigNumber): Promise<any> => {
-  const provider = getProvider();
-
-  if (!provider) return;
-
-  const signer = provider.getSigner();
-  const contract = new ethers.Contract(addresses.p2pix, p2pix.abi, signer);
-  const deposit = await contract.mapDeposits(depositId);
-
-  return deposit;
-};
-
 // Get specific lock data by its ID
 const mapLocks = async (lockId: string) => {
   const provider = getProvider();
@@ -251,12 +199,10 @@ export default {
   listReleaseTransactionByWalletAddress,
   listDepositTransactionByWalletAddress,
   listLockTransactionByWalletAddress,
-  mapDeposits,
   formatBigNumber,
   mapLocks,
   updateLockAddedEvents,
   updateValidDeposits,
-  getValidDeposits,
   updateLockReleasedEvents,
   updateDepositAddedEvents,
 };

src/views/HomeView.vue

@@ -8,8 +8,9 @@ import { ref } from "vue";
 import { useEtherStore } from "@/store/ether";
 import QrCodeComponent from "../components/QrCodeComponent.vue";
 import { storeToRefs } from "pinia";
-import { addLock, releaseLock } from "@/blockchain/methods";
+import { addLock, releaseLock } from "@/blockchain/buyerMethods";
 import { updateWalletStatus } from "@/blockchain/wallet";
+import { getNetworksLiquidity } from "@/blockchain/events";
 
 enum Step {
   Search,
@@ -19,6 +20,7 @@ enum Step {
 
 const etherStore = useEtherStore();
 etherStore.setSellerView(false);
+getNetworksLiquidity();
 
 // States
 const { loadingLock, walletAddress, locksAddedList } = storeToRefs(etherStore);

src/views/ManageBidsView.vue

@@ -5,7 +5,7 @@ import blockchain from "../utils/blockchain";
 import ListingComponent from "@/components/ListingComponent.vue";
 import type { BigNumber } from "ethers";
 import { ref, watch } from "vue";
-import { cancelDeposit, withdrawDeposit } from "@/blockchain/methods";
+import { cancelDeposit, withdrawDeposit } from "@/blockchain/buyerMethods";
 
 const etherStore = useEtherStore();
 

src/views/SellerView.vue

@@ -2,7 +2,7 @@
 import WantSellComponent from "../components/SellerSteps/WantSellComponent.vue";
 import SendNetwork from "../components/SellerSteps/SendNetwork.vue";
 import ValidationComponent from "../components/LoadingComponent.vue";
-import { approveTokens, addDeposit } from "../blockchain/methods";
+import { approveTokens, addDeposit } from "../blockchain/sellerMethods";
 
 import { ref } from "vue";
 import { useEtherStore } from "@/store/ether";