Add dynamic balances with mock rewards and distribution

README.md

@@ -70,6 +70,7 @@ npm run dev
 | `--fork` | Which live Ethereum network to fork locally | goerli | --fork=mainnet |
 | `--mock` | Whether to mock services | true | --mock=false |
 | `--network` | Which live Ethereum network to use | goerli | --network=mainnet |
+| `--simulation` | Whether to run contract simulation fixture | false | --simulation |
 
 **Example commands:**
 
@@ -106,18 +107,18 @@ npm run dev:landing
 
 ### Contracts
 
-Ethereum contracts are configured with a Hardhat development environment in the [contracts/ethereum/hardhat.config.ts](contracts/ethereum/hardhat.config.ts) file.
+Ethereum contracts are configured with a Hardhat development environment in the [contracts/ethereum/hardhat.config.ts](contracts/ethereum/hardhat.config.ts) file. Read more about `@casimir/ethereum` staking [here](contracts/ethereum/README.md). Below are some helpful commands for developing on or with the contracts.
 
 Run all contract tests.
 
 ```zsh
 npm run test:ethereum
 ```
 
-Compile the contracts in [contracts/ethereum](contracts/ethereum).
+Build the contracts in [contracts/ssv](contracts/ssv).
 
 ```zsh
-npm run task:compile --workspace @casimir/ethereum
+npm run build --workspace @casimir/ethereum
 ```
 
 Deploy a contract, specifically [contracts/ethereum/src/SSVManager.sol](contracts/ethereum/src/SSVManager.sol) with [contracts/ethereum/scripts/ssv.deploy.ts](contracts/ethereum/deploy/ssv.deploy.ts).

apps/web/src/components/Wallet.vue

@@ -1,11 +1,8 @@
 <template>
   <div>
     <div class="flex">
-      <button @click="getCurrentBalance()">
-        Get Balance New
-      </button>
-      <button @click="getUserBalance(selectedAddress)">
-        Get Balance Old
+      <button @click="getUserBalance()">
+        Get User Balance
       </button>
     </div>
     <div class="network-div w-100 mx-8">
@@ -43,21 +40,28 @@
       </button>
     </div>
     <div class="staking-container">
-      <button @click="getUserPools(selectedAddress)">
-        What do I have staked where?
+      <button @click="getPools(selectedAddress, 'ready')">
+        Get ready user pools
+      </button>
+      <button @click="getPools(selectedAddress, 'stake')">
+        Get staked user pools
       </button>
-      <ul>
+      <!-- <ul>
         <li
-          v-for="(pool, index) in user?.pools"
+          v-for="(account, index) in user?.accounts"
           :key="index"
         >
-          <p>Pool ID: #{{ pool.id }}</p>
-          <p>Your Stake: {{ pool.userStake }} ETH</p>
-          <p>Your Rewards: {{ pool.userRewards }} ETH</p>
-          <p>Total Stake: {{ pool.stake }} ETH</p>
-          <p>Total Rewards: {{ pool.rewards }} ETH</p>
+          <ul v-for="(pool, index) in account"
+            :key="index"
+          >
+            <li>Pool ID: #{{ pool?.id }}</li>
+            <li>Your Stake: {{ pool?.userStake }} ETH</li>
+            <li>Your Rewards: {{ pool?.userRewards }} ETH</li>
+            <li>Total Stake: {{ pool?.stake }} ETH</li>
+            <li>Total Rewards: {{ pool?.rewards }} ETH</li>
+          </ul>
         </li>
-      </ul>
+      </ul> -->
       <input
         v-model="amountToStake"
         placeholder="Amount to Stake"
@@ -214,12 +218,11 @@ const {
   sendTransaction,
   signMessage,
   getUserBalance,
-  getCurrentBalance,
   removeConnectedAccount,
   switchNetwork
 } = useWallet()
 
-const { deposit, getUserPools } = useSSV()
+const { deposit, getPools } = useSSV()
 
 watchEffect(() => {
   if (selectedProvider.value === 'MetaMask') {

apps/web/src/composables/ssv.ts

@@ -7,7 +7,8 @@ import useEthers from './ethers'
 import useLedger from './ledger'
 import useTrezor from './trezor'
 import useWalletConnect from './walletConnect'
-import { Pool, ProviderString } from '@casimir/types'
+import { Account, Pool, ProviderString } from '@casimir/types'
+import { ReadyOrStakeString } from '../interfaces'
 
 /** SSV Manager contract */
 let ssvManager: SSVManager
@@ -64,23 +65,28 @@ export default function useSSV() {
         return feesRounded
     }
 
-    async function getUserPools(userAddress: string): Promise<Pool[]> {
+    async function getPools(address: string, readyOrStake: ReadyOrStakeString): Promise<Pool[]> {
+        const { user } = useUsers()
         const provider = new ethers.providers.JsonRpcProvider(ethereumURL)
         const ssvManagerProvider = ssvManager.connect(provider)
-        const userPoolsIds = await ssvManagerProvider.getUserPoolIds(userAddress)
-        return await Promise.all(userPoolsIds.map(async (poolId: number) => {
-            const { balance, userBalance } = await ssvManagerProvider.getPoolUserDetails(poolId, userAddress)
+
+        const userStake = await ssvManagerProvider.getUserStake(address) // to get user's stake balance
+        const poolStake = await ssvManagerProvider.getStake() // to get total stake balance
+        const poolIds = readyOrStake === 'ready' ? await ssvManagerProvider.getReadyPoolIds() : await ssvManagerProvider.getStakedPoolIds() // to get ready (open) pool IDs OR to get staked (active) pool IDs
+
+        return await Promise.all(poolIds.map(async (poolId: number) => {
+            const { deposits, operatorIds, validatorPublicKey } = await ssvManagerProvider.getPool(poolId)
+
+            // TODO: Decide when/how to get rewards/userRewards
             let pool: Pool = {
                 id: poolId,
-                rewards: ethers.utils.formatEther(balance.rewards),
-                stake: ethers.utils.formatEther(balance.stake),
-                userRewards: ethers.utils.formatEther(userBalance.rewards),
-                userStake: ethers.utils.formatEther(userBalance.stake)
+                rewards: ethers.utils.formatEther(poolStake),
+                stake: ethers.utils.formatEther(poolStake),
+                userRewards: ethers.utils.formatEther(userStake),
+                userStake: ethers.utils.formatEther(userStake)
             }
 
-            const validatorPublicKey = await ssvManagerProvider.getPoolValidatorPublicKey(poolId) // Public key bytes (i.e., 0x..)
             if (validatorPublicKey) {
-
                 // Validator data from beaconcha.in hardcoded for now
                 // const response = await fetch(`https://prater.beaconcha.in/api/v1/validator/${validatorPublicKey}`)
                 // const { data } = await response.json()
@@ -92,9 +98,12 @@ export default function useSSV() {
                     apr: '0%', // See issue #205 https://github.com/consensusnetworks/casimir/issues/205#issuecomment-1338142532
                     url: `https://prater.beaconcha.in/validator/${validatorPublicKey}`
                 }
-                const operatorIds = await ssvManagerProvider.getPoolOperatorIds(poolId) // Operator ID uint32[] (i.e., [1, 2, 3, 4])
+
+
+                // TODO: Replace with less hardcoded network call?
                 const operators = await Promise.all(operatorIds.map(async (operatorId: number) => {
-                    const response = await fetch(`https://api.ssv.network/api/v3/operators/${operatorId}`)
+                    const network = 'prater'
+                    const response = await fetch(`https://api.ssv.network/api/v3/${network}/operators/${operatorId}`)
                     const { performance } = await response.json()
                     return {
                         id: operatorId,
@@ -111,12 +120,17 @@ export default function useSSV() {
                 }
             }
 
-            const { user } = useUsers()
-            user.value?.pools.push(pool)
+            if (readyOrStake === 'stake') {
+                user.value?.accounts.forEach((account: Account) => {
+                    if (account.address === address) {
+                        account.pools ? account.pools.push(pool) : account.pools = [pool]
+                    }
+                })
+            }
 
             return pool
         }))
     }
 
-    return { ssvManager, deposit, getDepositFees, getUserPools }
+    return { ssvManager, deposit, getDepositFees, getPools }
 }

apps/web/src/composables/users.ts

@@ -1,5 +1,5 @@
 import { onMounted, ref } from 'vue'
-import { AddAccountOptions, ProviderString, RemoveAccountOptions, User } from '@casimir/types'
+import { AddAccountOptions, ProviderString, RemoveAccountOptions, UserWithAccounts } from '@casimir/types'
 import { ethers } from 'ethers'
 import useEnvironment from '@/composables/environment'
 import useSSV from '@/composables/ssv'
@@ -8,73 +8,73 @@ import useWallet from '@/composables/wallet'
 const { usersBaseURL, ethereumURL } = useEnvironment()
 
 // 0xd557a5745d4560B24D36A68b52351ffF9c86A212
-// const user = ref<User>()
-const user = ref(
-    {
-        address: '0xd557a5745d4560B24D36A68b52351ffF9c86A212'.toLowerCase(),
-        accounts: [
-            {
-                address: '0xd557a5745d4560B24D36A68b52351ffF9c86A212'.toLowerCase(),
-                currency: 'ETH',
-                balance: '1000000000000000000',
-                balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
-                roi: 0.25,
-                walletProvider: 'MetaMask'
-            },
-            {
-                address: '0x1dc336d94890b10e1a47b6e34cdee1009ee7b942'.toLowerCase(),
-                currency: 'ETH',
-                balance: '1000000000000000000',
-                balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
-                roi: 0.25,
-                walletProvider: 'CoinbaseWallet'
-            },
-            {
-                address: '0x1dc336d94890b10e1a47b6e34cdee1009ee7b942'.toLowerCase(),
-                currency: 'ETH',
-                balance: '1000000000000000000',
-                balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
-                roi: 0.25,
-                walletProvider: 'CoinbaseWallet'
-            },
-            {
-                address: '0x1dc336d94890b10e1a47b6e34cdee1009ee7b942'.toLowerCase(),
-                currency: 'ETH',
-                balance: '1000000000000000000',
-                balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
-                roi: 0.25,
-                walletProvider: 'CoinbaseWallet'
-            },
-            {
-                address: '0x8222Ef172A2117D1C4739E35234E097630D94376'.toLowerCase(),
-                currency: 'ETH',
-                balance: '1000000000000000000',
-                balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
-                roi: 0.25,
-                walletProvider: 'Ledger'
-            },
-            {
-                address: '0x8222Ef172A2117D1C4739E35234E097630D94377'.toLowerCase(), // Fake address
-                currency: 'ETH',
-                balance: '1000000000000000000',
-                balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
-                roi: 0.25,
-                walletProvider: 'Trezor'
-            },
-            {
-                address: '0x8222Ef172A2117D1C4739E35234E097630D94378'.toLowerCase(), // Fake address
-                currency: 'ETH',
-                balance: '1000000000000000000',
-                balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
-                roi: 0.25,
-                walletProvider: 'WalletConnect'
-            },
-        ],
-        nonce: '1234567890',
-        pools: []
-    }
-)
-const { ssvManager } = useSSV()
+const user = ref<UserWithAccounts>()
+// const user = ref(
+//     {
+//         address: '0xd557a5745d4560B24D36A68b52351ffF9c86A212'.toLowerCase(),
+//         accounts: [
+//             {
+//                 address: '0xd557a5745d4560B24D36A68b52351ffF9c86A212'.toLowerCase(),
+//                 currency: 'ETH',
+//                 balance: '1000000000000000000',
+//                 balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
+//                 roi: 0.25,
+//                 walletProvider: 'MetaMask'
+//             },
+//             {
+//                 address: '0x1dc336d94890b10e1a47b6e34cdee1009ee7b942'.toLowerCase(),
+//                 currency: 'ETH',
+//                 balance: '1000000000000000000',
+//                 balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
+//                 roi: 0.25,
+//                 walletProvider: 'CoinbaseWallet'
+//             },
+//             {
+//                 address: '0x1dc336d94890b10e1a47b6e34cdee1009ee7b942'.toLowerCase(),
+//                 currency: 'ETH',
+//                 balance: '1000000000000000000',
+//                 balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
+//                 roi: 0.25,
+//                 walletProvider: 'CoinbaseWallet'
+//             },
+//             {
+//                 address: '0x1dc336d94890b10e1a47b6e34cdee1009ee7b942'.toLowerCase(),
+//                 currency: 'ETH',
+//                 balance: '1000000000000000000',
+//                 balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
+//                 roi: 0.25,
+//                 walletProvider: 'CoinbaseWallet'
+//             },
+//             {
+//                 address: '0x8222Ef172A2117D1C4739E35234E097630D94376'.toLowerCase(),
+//                 currency: 'ETH',
+//                 balance: '1000000000000000000',
+//                 balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
+//                 roi: 0.25,
+//                 walletProvider: 'Ledger'
+//             },
+//             {
+//                 address: '0x8222Ef172A2117D1C4739E35234E097630D94377'.toLowerCase(), // Fake address
+//                 currency: 'ETH',
+//                 balance: '1000000000000000000',
+//                 balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
+//                 roi: 0.25,
+//                 walletProvider: 'Trezor'
+//             },
+//             {
+//                 address: '0x8222Ef172A2117D1C4739E35234E097630D94378'.toLowerCase(), // Fake address
+//                 currency: 'ETH',
+//                 balance: '1000000000000000000',
+//                 balanceSnapshots: [{ date: '2023-02-06', balance: '1000000000000000000' }, { date: '2023-02-05', balance: '100000000000000000' }],
+//                 roi: 0.25,
+//                 walletProvider: 'WalletConnect'
+//             },
+//         ],
+//         nonce: '1234567890',
+//         pools: []
+//     }
+// )
+const { ssvManager, getPools } = useSSV()
 
 export default function useUsers () {
 
@@ -90,39 +90,40 @@ export default function useUsers () {
         return user
     }
 
-    function setUser(newUser?: User) {
+    function setUser(newUser?: UserWithAccounts) {
         user.value = newUser
     }
 
     // Todo filter for events for user addresses
     function subscribeToUserEvents() {
-        const { getUserBalance, getUserPools } = useWallet()
+        const { getUserBalance } = useWallet()
         const provider = new ethers.providers.JsonRpcProvider(ethereumURL)
 
         const validatorInitFilter = {
           address: ssvManager.address,
           topics: [
-            ethers.utils.id('ValidatorActivated(uint32,uint32[],string)')
+            ethers.utils.id('PoolStaked(uint32,bytes,uint32[])'),
+            // ethers.utils.id('ManagerDistribution(uint32,bytes,uint32[])'), // TODO: Make sure to query for past events on page load (Fetch and then subscribe)
           ]
         }
         ssvManager.connect(provider).on(validatorInitFilter, async () => {
           console.log('ValidatorInit event... updating pools')
-          user.value.balance = ethers.utils.formatEther(await getUserBalance(user.value.id))
-          user.value.pools = await getUserPools(user.value.id)
+          user.value.balance = await getUserBalance()
+          user.value.pools = await getPools(user.value.id)
           user.value.stake = user.value.pools?.reduce((a, c) => a + parseFloat(c.userStake), 0).toString()
           user.value.rewards = user.value.pools?.reduce((a, c) => a + parseFloat(c.userRewards), 0).toString()
         })
     }
 
     // onMounted(async () => {
-    //     const { getUserBalance, getUserPools } = useWallet()
+    //     const { getUserBalance } = useWallet()
     //     // Just get pools for primary account for demo
     //     user.value.balance = ethers.utils.formatEther(await getUserBalance(user.value.id))
-    //     user.value.pools = await getUserPools(user.value.id)
+    //     user.value.pools = await getPools(user.value.id)
     //     subscribeToUserEvents()
     // })
 
-    async function addAccount(account: AddAccountOptions): Promise<{ error: boolean, message: string, data: User | null }> {
+    async function addAccount(account: AddAccountOptions): Promise<{ error: boolean, message: string, data: UserWithAccounts | null }> {
         const requestOptions = {
             method: 'POST',
             headers: {