feat: added EVM supports

.eslintignore

@@ -7,5 +7,6 @@
 .eslintrc.js
 babel.config.js
 /src-ssr
+/src-pwa
 /tests/polkadot_wallet
 /tests/metamask_wallet

src/App.vue

@@ -82,7 +82,7 @@ export default defineComponent({
   setup() {
     useAppRouter();
     const store = useStore();
-    const { currentAccountName, currentAccount } = useAccount();
+    const { currentAccountName, currentAccount, senderSs58Account } = useAccount();
     const {
       protocolState,
       getAllRewards,
@@ -187,7 +187,7 @@ export default defineComponent({
       if (currentAccount.value && currentAccount.value !== previousAddress) {
         container
           .get<IDappStakingRepository>(Symbols.DappStakingRepositoryV3)
-          .startAccountLedgerSubscription(currentAccount.value);
+          .startAccountLedgerSubscription(senderSs58Account.value);
         fetchStakerInfoToStore();
         getAllRewards();
         fetchTiersConfigurationToStore();

src/staking-v3/components/Vote.vue

@@ -249,7 +249,9 @@ export default defineComponent({
         }
 
         if (selectedDappAddress.value) {
-          const dapp = dapps.value.find((dapp) => dapp.address === selectedDappAddress.value);
+          const dapp = dapps.value.find(
+            (dapp) => dapp.address.toLowerCase() === selectedDappAddress.value.toLowerCase()
+          );
           if (dapp) {
             selectedDapps.value = [dapp];
           }

src/staking-v3/components/my-staking/MyDapps.vue

@@ -66,7 +66,7 @@ export default defineComponent({
     },
   },
   setup() {
-    const { registeredDapps, getDapp } = useDapps();
+    const { getDapp } = useDapps();
     const { navigateToVote, navigateToMove } = useDappStakingNavigation();
     const { unstake, unstakeFromUnregistered } = useDappStaking();
 

src/staking-v3/hooks/useDappStaking.ts

@@ -1,6 +1,5 @@
 import { $api } from 'boot/api';
 import { computed } from 'vue';
-import { getShortenAddress } from '@astar-network/astar-sdk-core';
 import { container } from 'src/v2/common';
 import {
   AccountLedger,
@@ -40,7 +39,7 @@ export interface RewardsPerPeriod {
 export function useDappStaking() {
   const { t } = useI18n();
   const store = useStore();
-  const { currentAccount } = useAccount();
+  const { currentAccount, senderSs58Account } = useAccount();
   const { registeredDapps, fetchStakeAmountsToStore, getDapp } = useDapps();
   const { decimal } = useChainMetadata();
   const { useableBalance } = useBalance(currentAccount);
@@ -164,32 +163,36 @@ export function useDappStaking() {
       return;
     }
 
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
     await stakingService.claimUnstakeAndUnlock(
       dapp.chain.address,
       amount,
       currentAccount.value,
       t('stakingV3.unbondSuccess', { dapp: dapp.basic.name })
     );
-    const staker = await stakingService.getStakerRewards(currentAccount.value);
-    const bonus = await stakingService.getBonusRewards(currentAccount.value);
+    const staker = await stakingService.getStakerRewards(senderSs58Account.value);
+    const bonus = await stakingService.getBonusRewards(senderSs58Account.value);
     store.commit('stakingV3/setRewards', { ...rewards.value, staker, bonus });
     fetchStakerInfoToStore();
     getCurrentEraInfo();
     fetchStakeAmountsToStore();
   };
 
   const unstakeFromUnregistered = async (dappAddress: string, dappName: string): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
     await stakingService.claimAllAndUnstakeFromUnregistered(
       currentAccount.value,
       dappAddress,
       t('stakingV3.unbondFromUnregisteredSuccess', { dapp: dappName })
     );
 
     const [staker, bonus, dApp] = await Promise.all([
-      stakingService.getStakerRewards(currentAccount.value),
-      stakingService.getBonusRewards(currentAccount.value),
+      stakingService.getStakerRewards(senderSs58Account.value),
+      stakingService.getBonusRewards(senderSs58Account.value),
       stakingService.getDappRewards(dappAddress),
     ]);
     store.commit('stakingV3/setRewards', { ...rewards.value, staker, bonus, dApp });
@@ -199,9 +202,11 @@ export function useDappStaking() {
   };
 
   const claimStakerRewards = async (): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
     await stakingService.claimStakerRewards(currentAccount.value, 'success');
-    const staker = await stakingService.getStakerRewards(currentAccount.value);
+    const staker = await stakingService.getStakerRewards(senderSs58Account.value);
     store.commit('stakingV3/setRewards', { ...rewards.value, staker });
   };
 
@@ -211,7 +216,9 @@ export function useDappStaking() {
     unstakeFromAddress: string,
     unstakeAmount: bigint
   ): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
 
     await stakingService.claimLockAndStake(
       currentAccount.value,
@@ -230,15 +237,19 @@ export function useDappStaking() {
   };
 
   const claimBonusRewards = async (): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
+
     await stakingService.claimBonusRewards(currentAccount.value, 'success');
-    const bonus = await stakingService.getBonusRewards(currentAccount.value);
+    const bonus = await stakingService.getBonusRewards(senderSs58Account.value);
     store.commit('stakingV3/setRewards', { ...rewards.value, bonus });
   };
 
   const claimDappRewards = async (contractAddress: string): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
-
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
     if (contractAddress) {
       await stakingService.claimDappRewards(contractAddress, currentAccount.value, 'success');
       const dApp = await stakingService.getDappRewards(contractAddress);
@@ -249,24 +260,31 @@ export function useDappStaking() {
   };
 
   const claimStakerAndBonusRewards = async (): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
+
     await stakingService.claimStakerAndBonusRewards(
       currentAccount.value,
       t('stakingV3.claimRewardSuccess')
     );
-    const staker = await stakingService.getStakerRewards(currentAccount.value);
-    const bonus = await stakingService.getBonusRewards(currentAccount.value);
+    const staker = await stakingService.getStakerRewards(senderSs58Account.value);
+    const bonus = await stakingService.getBonusRewards(senderSs58Account.value);
     store.commit('stakingV3/setRewards', { ...rewards.value, staker, bonus });
   };
 
   const withdraw = async (): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
     await stakingService.claimUnlockedTokens(currentAccount.value, t('stakingV3.withdrawSuccess'));
     getCurrentEraInfo();
   };
 
   const relock = async (): Promise<void> => {
-    const stakingService = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
     await stakingService.relockUnlockingTokens(currentAccount.value, t('stakingV3.relockSuccess'));
   };
 
@@ -280,16 +298,18 @@ export function useDappStaking() {
   };
 
   const getAllRewards = async (): Promise<void> => {
-    const stakingV3service = container.get<IDappStakingService>(Symbols.DappStakingServiceV3);
+    const stakingV3service = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
     const ownedContractAddress = getOwnedDappAddress();
 
     let staker = BigInt(0);
     let dApp = BigInt(0);
     let bonus = BigInt(0);
 
     if (currentAccount.value) {
-      staker = await stakingV3service.getStakerRewards(currentAccount.value);
-      bonus = await stakingV3service.getBonusRewards(currentAccount.value);
+      staker = await stakingV3service.getStakerRewards(senderSs58Account.value);
+      bonus = await stakingV3service.getBonusRewards(senderSs58Account.value);
 
       if (ownedContractAddress) {
         dApp = await stakingV3service.getDappRewards(ownedContractAddress ?? '');
@@ -395,7 +415,7 @@ export function useDappStaking() {
     const stakingRepo = container.get<IDappStakingRepository>(Symbols.DappStakingRepositoryV3);
     const [constants, stakerInfo] = await Promise.all([
       stakingRepo.getConstants(),
-      stakingRepo.getStakerInfo(currentAccount.value, false),
+      stakingRepo.getStakerInfo(senderSs58Account.value, false),
     ]);
 
     if (amount <= 0) {
@@ -439,8 +459,10 @@ export function useDappStaking() {
       return;
     }
 
-    const stakingRepo = container.get<IDappStakingRepository>(Symbols.DappStakingRepositoryV3);
-    const stakerInfo = await stakingRepo.getStakerInfo(currentAccount.value, false);
+    const stakingService = container.get<() => IDappStakingService>(
+      Symbols.DappStakingServiceFactoryV3
+    )();
+    const stakerInfo = await stakingService.getStakerInfo(senderSs58Account.value, false);
 
     store.commit('stakingV3/setStakerInfo', stakerInfo, { root: true });
   };

src/staking-v3/hooks/useDappStakingNavigation.ts

@@ -6,7 +6,7 @@ export function useDappStakingNavigation() {
 
   const navigateToVote = (dAppAddress: string | undefined = undefined): void => {
     const base = networkParam + Path.DappStaking + Path.Vote;
-    router.push(`${base}?dappAddress=${dAppAddress ?? ''}`);
+    router.push(`${base}?dappAddress=${dAppAddress?.toLowerCase() ?? ''}`);
   };
 
   const navigateToMove = (dAppAddress: string): void => {

src/staking-v3/logic/services/DappStakingService.ts

@@ -1,5 +1,5 @@
 import { inject, injectable } from 'inversify';
-import { CombinedDappInfo, DappStakeInfo, StakeAmount } from '../models';
+import { CombinedDappInfo, DappStakeInfo, SingularStakingInfo, StakeAmount } from '../models';
 import { IDappStakingService } from './IDappStakingService';
 import { Symbols } from 'src/v2/symbols';
 import { IDappStakingRepository } from '../repositories';
@@ -109,7 +109,7 @@ export class DappStakingService implements IDappStakingService {
     await this.signCall(call, senderAddress, successMessage);
   }
 
-  private async getClaimStakerRewardsCall(
+  protected async getClaimStakerRewardsCall(
     senderAddress: string
   ): Promise<ExtrinsicPayload[] | undefined> {
     const { firstSpanIndex, lastSpanIndex, rewardsExpired, eraRewardSpanLength } =
@@ -201,7 +201,7 @@ export class DappStakingService implements IDappStakingService {
     await this.signCall(batch, senderAddress, successMessage);
   }
 
-  private async getClaimDappRewardsCalls(
+  protected async getClaimDappRewardsCalls(
     contractAddress: string
   ): Promise<ExtrinsicPayload[] | undefined> {
     const result = await this.getDappRewardsAndErasToClaim(contractAddress);
@@ -235,7 +235,7 @@ export class DappStakingService implements IDappStakingService {
     await this.signCall(batch, senderAddress, successMessage);
   }
 
-  private async getClaimStakerAndBonusRewardsCalls(
+  protected async getClaimStakerAndBonusRewardsCalls(
     senderAddress: string
   ): Promise<ExtrinsicPayload[]> {
     const claimStakerCalls = await this.getClaimStakerRewardsCall(senderAddress);
@@ -262,7 +262,7 @@ export class DappStakingService implements IDappStakingService {
     await this.signCall(batch, senderAddress, successMessage);
   }
 
-  private async getClaimBonusRewardsCalls(
+  protected async getClaimBonusRewardsCalls(
     senderAddress: string
   ): Promise<ExtrinsicPayload[] | undefined> {
     const result = await this.getBonusRewardsAndContractsToClaim(senderAddress);
@@ -283,6 +283,25 @@ export class DappStakingService implements IDappStakingService {
     unstakeAmount: bigint,
     successMessage: string
   ): Promise<void> {
+    this.guardStake(senderAddress, stakeInfo, unstakeFromAddress, unstakeAmount);
+
+    const batch = await this.getClaimLockAndStakeBatch(
+      senderAddress,
+      amountToLock,
+      stakeInfo,
+      unstakeFromAddress,
+      unstakeAmount
+    );
+
+    await this.signCall(batch, senderAddress, successMessage);
+  }
+
+  protected guardStake(
+    senderAddress: string,
+    stakeInfo: DappStakeInfo[],
+    unstakeFromAddress: string,
+    unstakeAmount: bigint
+  ): void {
     Guard.ThrowIfUndefined('senderAddress', senderAddress);
     if (stakeInfo.length === 0) {
       throw 'No stakeInfo provided';
@@ -294,7 +313,15 @@ export class DappStakingService implements IDappStakingService {
 
     // TODO there is a possibility that some address is wrong or some amount is below min staking amount
     // Check this also
+  }
 
+  protected async getClaimLockAndStakeBatch(
+    senderAddress: string,
+    amountToLock: bigint,
+    stakeInfo: DappStakeInfo[],
+    unstakeFromAddress: string,
+    unstakeAmount: bigint
+  ): Promise<ExtrinsicPayload> {
     const calls: ExtrinsicPayload[] = [];
 
     // Staker rewards
@@ -326,7 +353,8 @@ export class DappStakingService implements IDappStakingService {
     }
 
     const batch = await this.dappStakingRepository.batchAllCalls(calls);
-    await this.signCall(batch, senderAddress, successMessage);
+
+    return batch;
   }
 
   private async shouldCleanupExpiredEntries(senderAddress: string): Promise<boolean> {
@@ -527,6 +555,15 @@ export class DappStakingService implements IDappStakingService {
     return result;
   }
 
+  public async getStakerInfo(
+    address: string,
+    includePreviousPeriods: boolean
+  ): Promise<Map<string, SingularStakingInfo>> {
+    Guard.ThrowIfUndefined('address', address);
+
+    return await this.dappStakingRepository.getStakerInfo(address, includePreviousPeriods);
+  }
+
   private async getStakerEraRange(senderAddress: string) {
     const [protocolState, ledger, constants] = await Promise.all([
       this.dappStakingRepository.getProtocolState(),