Merge pull request #75 from lets-fucking-game/dev

Feat/ Dapp claim buttons

packages/dapp/src/config/types/typechain/contracts/GameV1.ts

@@ -53,6 +53,7 @@ export declare namespace GameV1Interface {
 
   export type GameDataStruct = {
     id: PromiseOrValue<BigNumberish>;
+    versionId: PromiseOrValue<BigNumberish>;
     roundId: PromiseOrValue<BigNumberish>;
     name: PromiseOrValue<BytesLike>;
     playerAddressesCount: PromiseOrValue<BigNumberish>;
@@ -70,6 +71,7 @@ export declare namespace GameV1Interface {
   };
 
   export type GameDataStructOutput = [
+    BigNumber,
     BigNumber,
     BigNumber,
     string,
@@ -87,6 +89,7 @@ export declare namespace GameV1Interface {
     string
   ] & {
     id: BigNumber;
+    versionId: BigNumber;
     roundId: BigNumber;
     name: string;
     playerAddressesCount: BigNumber;

packages/dapp/src/config/types/typechain/contracts/interfaces/GameV1Interface.ts

@@ -53,6 +53,7 @@ export declare namespace GameV1Interface {
 
   export type GameDataStruct = {
     id: PromiseOrValue<BigNumberish>;
+    versionId: PromiseOrValue<BigNumberish>;
     roundId: PromiseOrValue<BigNumberish>;
     name: PromiseOrValue<BytesLike>;
     playerAddressesCount: PromiseOrValue<BigNumberish>;
@@ -70,6 +71,7 @@ export declare namespace GameV1Interface {
   };
 
   export type GameDataStructOutput = [
+    BigNumber,
     BigNumber,
     BigNumber,
     string,
@@ -87,6 +89,7 @@ export declare namespace GameV1Interface {
     string
   ] & {
     id: BigNumber;
+    versionId: BigNumber;
     roundId: BigNumber;
     name: string;
     playerAddressesCount: BigNumber;

packages/dapp/src/config/types/typechain/factories/contracts/interfaces/GameV1Interface__factory.ts

@@ -527,6 +527,11 @@ const _abi = [
             name: "id",
             type: "uint256",
           },
+          {
+            internalType: "uint256",
+            name: "versionId",
+            type: "uint256",
+          },
           {
             internalType: "uint256",
             name: "roundId",

packages/dapp/src/state/games/fetchGameData.ts

@@ -30,14 +30,35 @@ export const fetchPublicGamesData = async (
   return chunk(gameMultiCallResult, chunkSize)
 }
 
-export const fetchGamesRemainingPlayersCount = async (
+export const fetchGamesCreatorAmounts = async (
   games: GameFactory.GameStructOutput[],
   chainId = ChainId.BSC,
 ): Promise<any[]> => {
   const gameCalls = games.map((game) => {
     return {
       address: game.deployedAddress,
-      name: 'getRemainingPlayersCount',
+      name: 'creatorAmount',
+    }
+  })
+  const chunkSize = gameCalls.length / games.length
+
+  const gameMultiCallResult = await multicallv2({
+    abi: internal[chainId || ChainId.BSC].GameV1.abi,
+    calls: gameCalls,
+    chainId,
+  })
+
+  return chunk(gameMultiCallResult, chunkSize)
+}
+
+export const fetchGamesTreasuryAmounts = async (
+  games: GameFactory.GameStructOutput[],
+  chainId = ChainId.BSC,
+): Promise<any[]> => {
+  const gameCalls = games.map((game) => {
+    return {
+      address: game.deployedAddress,
+      name: 'treasuryAmount',
     }
   })
   const chunkSize = gameCalls.length / games.length
@@ -96,3 +117,23 @@ export const fetchGamesPrizes = async (games: any[], chainId = ChainId.BSC): Pro
 
   return chunk(gameMultiCallResult, chunkSize)
 }
+
+export const fetchGamesWinners = async (games: any[], chainId = ChainId.BSC): Promise<any[]> => {
+  const gameCalls = games.map((game) => {
+    const roundId = game.roundId ? game.roundId - 1 : game.roundId
+    return {
+      address: game.address,
+      name: 'getWinners',
+      params: [roundId],
+    }
+  })
+  const chunkSize = gameCalls.length / games.length
+
+  const gameMultiCallResult = await multicallv2({
+    abi: internal[chainId || ChainId.BSC].GameV1.abi,
+    calls: gameCalls,
+    chainId,
+  })
+
+  return chunk(gameMultiCallResult, chunkSize)
+}

packages/dapp/src/state/games/fetchGamePlayerData.ts

@@ -80,94 +80,3 @@ export const fetchGamePlayersData = async (game: any, chainId = ChainId.BSC): Pr
 
   return chunk(gameMultiCallResult, chunkSize)
 }
-
-export const fetchGamePlayerAllowances = async (
-  account: string,
-  gamesToFetch: SerializedGame[],
-  chainId: number,
-  proxyAddress?: string,
-) => {
-  const isBscNetwork = verifyBscNetwork(chainId)
-
-  const calls = gamesToFetch.map((game) => {
-    const contractAddress = game.address
-    return { address: contractAddress, name: 'allowance', params: [account, proxyAddress] }
-  })
-
-  const rawLpAllowances = await multicall<BigNumber[]>(erc20ABI, calls, chainId)
-  const parsedLpAllowances = rawLpAllowances.map((lpBalance) => {
-    return new BigNumber(lpBalance).toJSON()
-  })
-
-  return parsedLpAllowances
-}
-
-export const fetchGamePlayerTokenBalances = async (
-  account: string,
-  gamesToFetch: SerializedGame[],
-  chainId: number,
-) => {
-  const calls = gamesToFetch.map((game) => {
-    const contractAddress = game.address
-    return {
-      address: contractAddress,
-      name: 'balanceOf',
-      params: [account],
-    }
-  })
-
-  const rawTokenBalances = await multicall(erc20ABI, calls, chainId)
-  const parsedTokenBalances = rawTokenBalances.map((tokenBalance) => {
-    return new BigNumber(tokenBalance).toJSON()
-  })
-  return parsedTokenBalances
-}
-
-export const fetchGamePlayerStakedBalances = async (
-  account: string,
-  gamesToFetch: SerializedGame[],
-  chainId: number,
-) => {
-  const isBscNetwork = verifyBscNetwork(chainId)
-
-  const calls = gamesToFetch.map((game) => {
-    return {
-      address: account,
-      name: 'userInfo',
-      params: [game.id],
-    }
-  })
-
-  const rawStakedBalances = await multicallv2({
-    abi: isBscNetwork ? null : null,
-    calls,
-    chainId,
-    options: { requireSuccess: false },
-  })
-  const parsedStakedBalances = rawStakedBalances.map((stakedBalance) => {
-    return new BigNumber(stakedBalance[0]._hex).toJSON()
-  })
-  return parsedStakedBalances
-}
-
-export const fetchGamePlayerEarnings = async (account: string, gamesToFetch: SerializedGame[], chainId: number) => {
-  const isBscNetwork = verifyBscNetwork(chainId)
-  const multiCallChainId = isChainTestnet(chainId) ? ChainId.BSC_TESTNET : ChainId.BSC
-  const userAddress = account
-
-  const calls = gamesToFetch.map((game) => {
-    return {
-      address: account,
-      name: 'pendingCake',
-      params: [game.id, userAddress],
-    }
-  })
-
-  const rawEarnings = await multicallv2({ abi: null, calls, chainId: multiCallChainId })
-
-  const parsedEarnings = rawEarnings.map((earnings) => {
-    return new BigNumber(earnings).toJSON()
-  })
-
-  return parsedEarnings
-}

packages/dapp/src/state/games/fetchGames.ts

@@ -1,9 +1,44 @@
 import { getGameFactoryV1Contract } from 'utils/contractHelpers'
 import { GameFactory } from 'config/types/typechain'
 
-const fetchGames = async (chainId: number): Promise<GameFactory.GameStructOutput[]> => {
-  const gameFactoryContract: GameFactory = getGameFactoryV1Contract(chainId)
-  return gameFactoryContract.getDeployedGames()
+import { gameBaseTransformer, gameExtendedTransformer } from './transformers'
+
+import {
+  fetchPublicGamesData,
+  fetchGamesTreasuryAmounts,
+  fetchGamesCreatorAmounts,
+  fetchGamesPlayersAddresses,
+  fetchGamesPrizes,
+  fetchGamesWinners,
+  fetchGamesPlayersData,
+} from './fetchGameData'
+import { State, SerializedGame, DeserializedGame, DeserializedGameUserData } from '../types'
+
+const fetchGames = async (chainId: number): Promise<SerializedGame[]> => {
+  try {
+    const gameFactoryContract: GameFactory = getGameFactoryV1Contract(chainId)
+    const gamesToFetch: GameFactory.GameStructOutput[] = await gameFactoryContract.getDeployedGames()
+
+    const [gameData, gamePlayers, gameCreatorAmounts, gameTreasuryAmounts] = await Promise.all([
+      fetchPublicGamesData(gamesToFetch, chainId),
+      fetchGamesPlayersAddresses(gamesToFetch, chainId),
+      fetchGamesCreatorAmounts(gamesToFetch, chainId),
+      fetchGamesTreasuryAmounts(gamesToFetch, chainId),
+    ])
+    const transformedGames = gamesToFetch.map(
+      gameBaseTransformer(gameData, gamePlayers, gameCreatorAmounts, gameTreasuryAmounts),
+    )
+
+    const [gamePrizes, gameWinners] = await Promise.all([
+      fetchGamesPrizes(transformedGames, chainId),
+      fetchGamesWinners(transformedGames, chainId),
+    ])
+    const completeGames = transformedGames.map(gameExtendedTransformer(gamePrizes, gameWinners))
+    return completeGames
+  } catch (e) {
+    console.log('🚀 ~ file: fetchGames.ts ~ line 21 ~ fetchGames ~ e', e)
+    return []
+  }
 }
 
 export default fetchGames

packages/dapp/src/state/games/fetchGamesFull.ts

@@ -1,11 +1,12 @@
 import { getGameFactoryV1Contract } from 'utils/contractHelpers'
 import { GameFactory } from 'config/types/typechain'
 
-import { gameBaseTransformer, gameExtendedTransformer } from './transformers'
+import { gameBaseTransformer, gameFullTransformer } from './transformers'
 
 import {
   fetchPublicGamesData,
-  fetchGamesRemainingPlayersCount,
+  fetchGamesTreasuryAmounts,
+  fetchGamesCreatorAmounts,
   fetchGamesPlayersAddresses,
   fetchGamesPrizes,
   fetchGamesPlayersData,
@@ -16,17 +17,22 @@ const fetchGamesFull = async (chainId: number): Promise<SerializedGame[]> => {
   const gameFactoryContract: GameFactory = getGameFactoryV1Contract(chainId)
   const gamesToFetch: GameFactory.GameStructOutput[] = await gameFactoryContract.getDeployedGames()
 
-  const [gameData, gamePlayers] = await Promise.all([
+  const [gameData, gamePlayers, gameCreatorAmounts, gameTreasuryAmounts] = await Promise.all([
     fetchPublicGamesData(gamesToFetch, chainId),
     fetchGamesPlayersAddresses(gamesToFetch, chainId),
+    fetchGamesCreatorAmounts(gamesToFetch, chainId),
+    fetchGamesTreasuryAmounts(gamesToFetch, chainId),
   ])
-  const transformedGames = gamesToFetch.map(gameBaseTransformer(gameData, gamePlayers))
+  const transformedGames = gamesToFetch.map(
+    gameBaseTransformer(gameData, gamePlayers, gameCreatorAmounts, gameTreasuryAmounts),
+  )
+
   // TODO GUIGUI HANDLE gamePlayersData
   const [gamePrizes /* , gamePlayersData */] = await Promise.all([
     fetchGamesPrizes(transformedGames, chainId),
     // fetchGamesPlayersData(transformedGames, chainId),
   ])
-  const completeGames = transformedGames.map(gameExtendedTransformer(gamePrizes /* , gamePlayersData */))
+  const completeGames = transformedGames.map(gameFullTransformer(gamePrizes /* , gamePlayersData */))
   return completeGames
 }
 

packages/dapp/src/state/games/index.ts

@@ -11,11 +11,11 @@ import { chains } from 'utils/wagmi'
 
 import { resetUserState } from '../global/actions'
 import { SerializedGame, SerializedGamesState, SerializedGamePlayerData } from '../types'
-import fetchGamesFull from './fetchGamesFull'
+import fetchGames from './fetchGames'
 import { fetchGamesPlayerData } from './fetchGamePlayerData'
 import { gamePlayerDataTransformer } from './transformers'
 
-const fetchGamePublicDataPkg = async ({ chainId }): Promise<SerializedGame[]> => fetchGamesFull(chainId)
+const fetchGamePublicDataPkg = async ({ chainId }): Promise<SerializedGame[]> => fetchGames(chainId)
 
 const initialState: SerializedGamesState = {
   data: [],
@@ -43,12 +43,11 @@ export const fetchInitialGamesData = createAsyncThunk<
         isPlaying: false,
         isCreator: false,
         isAdmin: false,
-        wonAmount: '0',
         nextFromRange: '0',
         nextToRange: '0',
-        isWonLastGames: false,
         isCanVoteSplitPot: false,
         isInTimeRange: false,
+        isLoosing: false,
       },
       playerData: {
         playerAddress: '',
@@ -165,6 +164,7 @@ export const fetchGamePlayerDataAsync = createAsyncThunk<
 
     const playerData = await fetchGamesPlayerData(games, account, chainId)
 
+    // TODO GUIGUI LOAD ROUND WINNERS HISTORY AND CHECK IF PLAYER HAS WON
     return games.map(gamePlayerDataTransformer(playerData, account))
   },
   {
@@ -209,12 +209,11 @@ export const gamesSlice = createSlice({
             isPlaying: false,
             isCreator: false,
             isAdmin: false,
-            wonAmount: '0',
             nextFromRange: '0',
             nextToRange: '0',
-            isWonLastGames: false,
             isCanVoteSplitPot: false,
             isInTimeRange: false,
+            isLoosing: false,
           },
           playerData: {
             playerAddress: '',