rounds implemented + over all improvements

src/stores/memeburner.js

@@ -13,7 +13,7 @@ export const useMemeburnerStore = defineStore("memeburner", {
 		async getCurrentRound() {
 			return await this.contract.methods.currentRound().call();
 		},
-		async getGoal(roundnumber) {
+		async getGoal   (roundnumber) {
 			return await this.contract.methods.rounds(roundnumber).call();
 		},
 		//returns participated, amount achieved
@@ -21,6 +21,7 @@ export const useMemeburnerStore = defineStore("memeburner", {
 			return await this.contract.methods.getSacrificedMeme(roundnumber, tokenAddress).call();
 		},
         async getSacrificedRound(roundnumber) {
+            console.log("getSacrificedRound", roundnumber);
             const tokenStore = useTokenStore();
             const calls = [];
             for (let index = 0; index < tokenStore.token.length; index++) {

src/stores/rewardlocker.js

@@ -1,5 +1,8 @@
 import { defineStore } from "pinia";
 import RewardLockerJson from "@/assets/contracts/RewardLocker.json";
+import { useTokenStore } from "./tokens";
+import { useMultiCallStore } from "./multicall";
+import { useWalletStore } from "./wallet";
 
 export const useRewardLockerStore = defineStore("rewardlocker", {
 	state: () => ({
@@ -17,8 +20,26 @@ export const useRewardLockerStore = defineStore("rewardlocker", {
 		async getRewards(walletAddress, roundNumber, tokenAddress) {
 			return await this.contract.methods.rewards(walletAddress, roundNumber, tokenAddress).call();
 		},
+        async getRewardsForAllToken(roundNumber) {   
+            console.log("getRewardsForAllToken");
+            const tokenStore = useTokenStore();
+            const walletStore = useWalletStore();
+			const calls = [];
+			for (let index = 0; index < tokenStore.token.length; index++) {
+				const token = tokenStore.token[index];
+				calls.push(this.contract.methods.rewards(walletStore.address, roundNumber, token.contractAddress));
+			}
+			const multicallStore = useMultiCallStore();
+            return await multicallStore.aggregate(calls);
+		},
 		async lastCompletedRound() {
 			return await this.contract.methods.lastCompletedRound().call();
 		},
+		async claim(round) {
+			return await this.contract.methods.claim(round).call();
+		},
+		async getTotalRewardsOf(address, rounds) {
+			return await this.contract.methods.getTotalRewardsOf(address, rounds).call();
+		},
 	},
 });

src/stores/rounds.js

@@ -0,0 +1,64 @@
+import { defineStore } from "pinia";
+import { useMemeburnerStore } from "./memeburner";
+import { useTokenStore } from "./tokens";
+import { useRewardLockerStore } from "./rewardlocker";
+
+
+export const useRoundsStore = defineStore("rounds", {
+	state: () => ({
+        rounds: [
+        ],
+        activeRound: null,
+        currentRound: null
+	}),
+    getters: {
+        getCurrentRoundData() {
+            return this.rounds[this.activeRound];
+        }
+    },
+    actions: {
+        async updateCurrentRound(sacrificedToken, sacrificedAmount) {
+            const tokenStore = useTokenStore();
+            const memeBurnerStore = useMemeburnerStore();
+            var data = await memeBurnerStore.getSacrificedRound(this.currentRound)
+            var tokenIndex = this.rounds[this.currentRound].token.findIndex((tokenData) => tokenData.contractAddress === sacrificedToken);
+            this.rounds[this.currentRound].token[tokenIndex].amount = data[tokenIndex][1];
+        },
+        async fillRound() {
+            console.log("fillRound");
+            const memeBurnerStore = useMemeburnerStore();
+            const tokenStore = useTokenStore();
+            const rewardLockerStore = useRewardLockerStore();
+
+            // if (this.activeRound === this.currentRound) {
+            //     console.log("activeRound is not completed");
+            // } else
+                if (!this.rounds[this.activeRound]) {
+                console.log("round not filled --> fill round");
+                var data = await memeBurnerStore.getSacrificedRound(this.activeRound)
+                var rewardData = await rewardLockerStore.getRewardsForAllToken(this.activeRound);
+                var goal = await memeBurnerStore.getGoal(this.activeRound);
+                console.log("data", data);
+                var tokenArray = []
+                for (let index = 0; index < data.length; index++) {
+                    var tokenData = {};
+                    const token = tokenStore.token[index];
+                    console.log("token", token);
+                    tokenData.name = token.name;
+                    tokenData.contractAddress = token.contractAddress;
+                    tokenData.vamplogo = token.vamp.logo;
+                    tokenData.vampname = token.vamp.name;
+                    tokenData.amount = data[index][1];
+                    tokenData.rewards = rewardData[index]
+                    tokenArray.push(tokenData);
+                }
+                    this.rounds[this.activeRound] = {
+                        goal: goal, token: tokenArray
+                    }
+            } else {
+                console.log("round already filled");
+            }
+            console.log("this.rounds123", this.rounds);
+        },
+    },
+});

src/stores/tokens.js

@@ -4,6 +4,7 @@ import { useWalletStore } from "./wallet";
 import { useContractStore } from "./contracts";
 import Meme1Json from "@/assets/contracts/Meme1.json";
 import Meme2Json from "@/assets/contracts/Meme2.json";
+import MemeToken from "@/assets/contracts/MemeToken.json";
 import MemeBurnerJson from "@/assets/contracts/MemeBurner.json";
 
 export const useTokenStore = defineStore("token", {
@@ -19,7 +20,7 @@ export const useTokenStore = defineStore("token", {
 				},
 				backgroundColor: "#4b8501",
 				abi: Meme1Json.abi,
-                contractAddress: Meme1Json.contractAddress,
+				contractAddress: Meme1Json.contractAddress,
 			},
 			{
 				name: "$SHIB",
@@ -52,6 +53,12 @@ export const useTokenStore = defineStore("token", {
 			allowance: null,
 		},
 		loading: false,
+        memeToken: {
+            config: {
+                abi: MemeToken.abi,
+                contractAddress: MemeToken.contractAddress
+            }
+		},
 		memeBurner: {
 			config: MemeBurnerJson,
 			contract: null,
@@ -76,30 +83,49 @@ export const useTokenStore = defineStore("token", {
 				.allowance(walletStore.address, MemeBurnerJson.contractAddress)
 				.call();
 			console.log("allowance", allowance);
+			var decimals = await this.contract.methods.decimals().call();
+			console.log("decimals", decimals);
 			return allowance;
 		},
 		async approveToken(amount) {
-			const walletStore = useWalletStore();
-			this.loading = true;
-			var approve = await this.contract.methods
-				.approve(this.memeBurner.config.contractAddress, amount)
-				.send({ from: walletStore.address });
-			console.log("approve", approve);
-			this.loading = false;
-			return approve;
+			try {
+				console.log("amount", amount);
+				this.loading = true;
+				const walletStore = useWalletStore();
+				var approve = await this.contract.methods
+					.approve(this.memeBurner.config.contractAddress, amount)
+					.send({ from: walletStore.address });
+				//todo parameter value übergeben in eth web3.utils.toHex(web3.utils.toWei(amount, 'ether'))
+
+				// .send({ from: walletStore.address, value: 0.5 });
+				console.log("approve", approve);
+				this.activeToken.allowance = await this.allowance();
+				return approve;
+			} catch (error) {
+				console.error(error);
+			} finally {
+				this.loading = false;
+			}
 		},
 		async sacrificeToken(amount) {
 			try {
+				console.log("amount", amount);
+				if (!amount || amount == 0) {
+					//todo error
+					console.error("amount is 0 or null or undefined");
+					return;
+				}
 				this.loading = true;
 				console.log("this.activeToken.", this.activeToken.contractAddress);
 				const walletStore = useWalletStore();
 				console.log("walletStore.address", walletStore.address);
 				var reward = await this.memeBurner.contract.methods
-					.sacrificeMeme(this.activeToken.contractAddress, "400000000000000000")
+					.sacrificeMeme(this.activeToken.contractAddress, amount)
 					.send({ from: walletStore.address });
 				console.log("reward", reward);
+				this.activeToken.allowance = await this.allowance();
 			} catch (error) {
-				error.log(error);
+				console.error(error);
 			} finally {
 				this.loading = false;
 			}