feat: check for custom min voting power when voting

apps/ui/src/components/MessageVotingPower.vue

@@ -1,14 +1,26 @@
 <script setup lang="ts">
 import { VotingPowerItem } from '@/stores/votingPowers';
 
-defineProps<{
+const props = defineProps<{
   votingPower: VotingPowerItem;
   action?: 'vote' | 'propose';
 }>();
 
 defineEmits<{
   (e: 'fetchVotingPower');
 }>();
+
+const insufficientVp: ComputedRef<boolean> = computed(() => {
+  return !!(
+    props.votingPower.threshold.vote && props.votingPower.totalVotingPower > 0n
+  );
+});
+
+const formattedVotingThreshold = computed(() => {
+  return (
+    Number(props.votingPower.threshold.vote) / 10 ** props.votingPower.decimals
+  );
+});
 </script>
 
 <template>
@@ -33,7 +45,12 @@ defineEmits<{
     type="error"
     v-bind="$attrs"
   >
-    You do not have enough voting power to vote.
+    <span v-if="insufficientVp">
+      You need at least a voting power of
+      <i> {{ formattedVotingThreshold }} {{ votingPower.symbol }} </i>
+      to vote.
+    </span>
+    <span v-else> You do not have enough voting power to vote. </span>
   </UiAlert>
   <UiAlert
     v-else-if="action === 'propose' && !votingPower.canPropose"

apps/ui/src/networks/common/graphqlApi/index.ts

@@ -265,7 +265,9 @@ function formatProposal(
     state: getProposalState(proposal, current),
     network: networkId,
     privacy: null,
-    quorum: +proposal.quorum
+    quorum: +proposal.quorum,
+    validation: 'any',
+    validation_params: {}
   };
 }
 

apps/ui/src/networks/offchain/api/index.ts

@@ -244,6 +244,8 @@ function formatProposal(proposal: ApiProposal, networkId: NetworkID): Proposal {
     strategies: proposal.strategies.map(strategy => strategy.name),
     strategies_indicies: [],
     strategies_params: proposal.strategies.map(strategy => strategy),
+    validation: proposal.validation.name,
+    validation_params: proposal.validation.params,
     tx: '',
     execution_tx: null,
     veto_tx: null,

apps/ui/src/networks/offchain/api/queries.ts

@@ -81,6 +81,10 @@ const PROPOSAL_FRAGMENT = gql`
       params
       network
     }
+    validation {
+      name
+      params
+    }
     created
     updated
     votes

apps/ui/src/networks/offchain/api/types.ts

@@ -72,6 +72,7 @@ export type ApiProposal = {
   scores_total: number;
   state: 'active' | 'pending' | 'closed';
   strategies: { network: string; params: Record<string, any>; name: string }[];
+  validation: { name: string; params: Record<string, any> };
   created: number;
   updated: number | null;
   votes: number;

apps/ui/src/stores/votingPowers.ts

@@ -16,6 +16,10 @@ export type VotingPowerItem = {
   error: utils.errors.VotingPowerDetailsError | null;
   canPropose: boolean;
   canVote: boolean;
+  threshold: {
+    propose?: bigint;
+    vote?: bigint;
+  };
 };
 
 export function getIndex(space: SpaceDetails, block: number | null): string {
@@ -45,7 +49,8 @@ export const useVotingPowersStore = defineStore('votingPowers', () => {
       symbol: space.voting_power_symbol,
       error: null,
       canPropose: false,
-      canVote: false
+      canVote: false,
+      threshold: {}
     };
 
     if (existingVotingPower) {
@@ -75,10 +80,13 @@ export const useVotingPowersStore = defineStore('votingPowers', () => {
       };
 
       if ('proposal_threshold' in space) {
-        vpItem.canPropose =
-          vpItem.totalVotingPower >= BigInt(space.proposal_threshold);
+        vpItem.threshold.propose = BigInt(space.proposal_threshold);
+        vpItem.canPropose = vpItem.totalVotingPower >= vpItem.threshold.propose;
       } else {
-        vpItem.canVote = vpItem.totalVotingPower > 0n;
+        vpItem.threshold.vote = BigInt(
+          ((item as Proposal).validation_params.minScore || 0) * 10 ** 18
+        );
+        vpItem.canVote = vpItem.totalVotingPower > vpItem.threshold.vote;
       }
     } catch (e: unknown) {
       if (e instanceof utils.errors.VotingPowerDetailsError) {

apps/ui/src/types.ts

@@ -200,6 +200,11 @@ export type Proposal = {
   strategies_indicies: number[];
   strategies: string[];
   strategies_params: any[];
+  validation: string;
+  validation_params: {
+    minScore?: number;
+    strategies?: Record<string, any>[];
+  };
   created: number;
   edited: number | null;
   tx: string;