;
}
-export const ProposalsList = ({ proposals }: ProposalsListProps) => {
+interface SortedProtocolUpgradeProposalsProps {
+ open: ProtocolUpgradeProposalFieldsFragment[];
+ closed: ProtocolUpgradeProposalFieldsFragment[];
+}
+
+export const ProposalsList = ({
+ proposals,
+ protocolUpgradeProposals,
+ lastBlockHeight,
+}: ProposalsListProps) => {
const { t } = useTranslation();
const [filterString, setFilterString] = useState('');
const sortedProposals = proposals.reduce(
@@ -39,6 +52,21 @@ export const ProposalsList = ({ proposals }: ProposalsListProps) => {
}
);
+ const sortedProtocolUpgradeProposals = protocolUpgradeProposals.reduce(
+ (acc: SortedProtocolUpgradeProposalsProps, proposal) => {
+ if (Number(proposal?.upgradeBlockHeight) > Number(lastBlockHeight)) {
+ acc.open.push(proposal);
+ } else {
+ acc.closed.push(proposal);
+ }
+ return acc;
+ },
+ {
+ open: [],
+ closed: [],
+ }
+ );
+
const filterPredicate = (
p: ProposalFieldsFragment | ProposalQuery['proposal']
) =>
@@ -65,7 +93,7 @@ export const ProposalsList = ({ proposals }: ProposalsListProps) => {
{t(
- `The Vega network is governed by the community. View active proposals, vote on them or propose changes to the network.`
+ `The Vega network is governed by the community. View active proposals, vote on them or propose changes to the network. Network upgrades are proposed and approved by validators.`
)}{' '}
{
)}
+ {sortedProtocolUpgradeProposals.open.map((proposal) => (
+
+ {sortedProtocolUpgradeProposals.closed.map((proposal) => (
+
+
+
+
+ {`${consensusApprovalsVotingPowerPercentage} ${t(
+ 'approval (% validator voting power)'
+ )}`}
+ ({t('67% voting power required')})
+
+
+
+
+
+
+
+
+
+
+ {t('validator')}
+ {t('votingPower')}
+
+
+ {consensusApprovals.map((validator, index) => (
+
+
+
+
+
+ {getNormalisedVotingPower(
+ validator.rankingScore.votingPower,
+ 2
+ )}
+
+
+ ))}
+
+
+
= {}
+ ) => {
+ const mergedProps = {
+ ...defaultProps,
+ ...props,
+ };
+ return render(
+
+
+ );
+ };
+
+ it('renders without crashing', () => {
+ renderComponent();
+ expect(
+ screen.getByTestId('protocol-upgrade-approval-status')
+ ).toBeInTheDocument();
+ expect(
+ screen.getByTestId('protocol-upgrade-approvers')
+ ).toBeInTheDocument();
+ });
+
+ it('renders the correct number of consensus approvers', () => {
+ renderComponent();
+ const validators = screen.getAllByTestId(/validator-/i);
+ expect(validators.length).toBe(mockValidators.length);
+ });
+
+ it('renders the correct approval status with the required percentage', () => {
+ renderComponent();
+ expect(screen.getByText(/75% approval/i)).toBeInTheDocument();
+ expect(screen.getByText(/67% voting power required/i)).toBeInTheDocument();
+ });
+
+ it('renders the correct voting power for each validator', () => {
+ renderComponent();
+ mockValidators.forEach((validator) => {
+ const normalisedVotingPower = getNormalisedVotingPower(
+ validator.rankingScore.votingPower,
+ 2
+ );
+ expect(screen.getByText(normalisedVotingPower)).toBeInTheDocument();
+ });
+ });
+});
diff --git a/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-header/index.tsx b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-header/index.tsx
new file mode 100644
index 000000000..8ad369de8
--- /dev/null
+++ b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-header/index.tsx
@@ -0,0 +1 @@
+export * from './protocol-upgrade-proposal-detail-header';
diff --git a/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-header/protocol-upgrade-proposal-detail-header.spec.tsx b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-header/protocol-upgrade-proposal-detail-header.spec.tsx
new file mode 100644
index 000000000..2d7f8e978
--- /dev/null
+++ b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-header/protocol-upgrade-proposal-detail-header.spec.tsx
@@ -0,0 +1,18 @@
+import { render } from '@testing-library/react';
+import { ProtocolUpgradeProposalDetailHeader } from './protocol-upgrade-proposal-detail-header';
+
+describe('ProtocolUpgradeProposalDetailHeader', () => {
+ it('should render successfully', () => {
+ const { baseElement } = render(
+
+ {t('networkUpgrade')}
+
+
+ );
+};
diff --git a/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-info/index.tsx b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-info/index.tsx
new file mode 100644
index 000000000..ea34734b2
--- /dev/null
+++ b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-info/index.tsx
@@ -0,0 +1 @@
+export * from './protocol-upgrade-proposal-detail-info';
diff --git a/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-info/protocol-upgrade-proposal-detail-info.spec.tsx b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-info/protocol-upgrade-proposal-detail-info.spec.tsx
new file mode 100644
index 000000000..2ec6b2f65
--- /dev/null
+++ b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposal-detail-info/protocol-upgrade-proposal-detail-info.spec.tsx
@@ -0,0 +1,44 @@
+// jest tests for the protocol upgrade proposal detail info component
+
+import { render } from '@testing-library/react';
+import { ProtocolUpgradeProposalStatus } from '@vegaprotocol/types';
+import { ProtocolUpgradeProposalDetailInfo } from './protocol-upgrade-proposal-detail-info';
+
+const renderComponent = () =>
+ render(
+
+
+
+
+ {t('upgradeBlockHeight')}
+
+
+ {proposal.upgradeBlockHeight}{' '}
+ {lastBlockHeight && (
+ <>
+ ({t('currently')} {lastBlockHeight})
+
+ )}
+
+
+
+
+ {t('state')}
+
+
+ {t(`${proposal.status}`)}
+
+
+
+
+ {t('vegaReleaseTag')}
+
+
+ {proposal.vegaReleaseTag}
+
+
+
+
+
+ );
+};
diff --git a/apps/governance/src/routes/proposals/components/protocol-upgrade-proposals-list-item/protocol-upgrade-proposals-list-item.spec.tsx b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposals-list-item/protocol-upgrade-proposals-list-item.spec.tsx
new file mode 100644
index 000000000..65b78c073
--- /dev/null
+++ b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposals-list-item/protocol-upgrade-proposals-list-item.spec.tsx
@@ -0,0 +1,69 @@
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { BrowserRouter } from 'react-router-dom';
+import { ProtocolUpgradeProposalsListItem } from './protocol-upgrade-proposals-list-item';
+import { ProtocolUpgradeProposalStatus } from '@vegaprotocol/types';
+import type { ProtocolUpgradeProposalFieldsFragment } from '../../protocol-upgrade/__generated__/ProtocolUpgradeProposals';
+
+const proposal = {
+ status:
+ ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_PENDING,
+ vegaReleaseTag: 'v1.0.0',
+ upgradeBlockHeight: '12345',
+} as ProtocolUpgradeProposalFieldsFragment;
+
+const renderComponent = (proposal: ProtocolUpgradeProposalFieldsFragment) =>
+ render(
+
+
+ );
+
+describe('ProtocolUpgradeProposalsListItem', () => {
+ it('renders the correct status icon for each proposal status', () => {
+ const statuses = [
+ {
+ status:
+ ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_REJECTED,
+ icon: 'protocol-upgrade-proposal-status-icon-rejected',
+ },
+ {
+ status:
+ ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_PENDING,
+ icon: 'protocol-upgrade-proposal-status-icon-pending',
+ },
+ {
+ status:
+ ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_APPROVED,
+ icon: 'protocol-upgrade-proposal-status-icon-approved',
+ },
+ {
+ status:
+ ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_UNSPECIFIED,
+ icon: 'protocol-upgrade-proposal-status-icon-unspecified',
+ },
+ ];
+
+ statuses.forEach(({ status, icon }) => {
+ renderComponent({ ...proposal, status });
+ const statusIcon = screen.getByTestId(icon);
+ expect(statusIcon).toBeInTheDocument();
+ });
+ });
+
+ it('renders the correct Vega release tag', () => {
+ renderComponent(proposal);
+ const releaseTag = screen.getByTestId(
+ 'protocol-upgrade-proposal-release-tag'
+ );
+ expect(releaseTag).toHaveTextContent(proposal.vegaReleaseTag);
+ });
+
+ it('renders the correct upgrade block height', () => {
+ renderComponent(proposal);
+ const blockHeight = screen.getByTestId(
+ 'protocol-upgrade-proposal-block-height'
+ );
+ expect(blockHeight).toHaveTextContent(proposal.upgradeBlockHeight);
+ });
+});
diff --git a/apps/governance/src/routes/proposals/components/protocol-upgrade-proposals-list-item/protocol-upgrade-proposals-list-item.tsx b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposals-list-item/protocol-upgrade-proposals-list-item.tsx
new file mode 100644
index 000000000..c4be5acda
--- /dev/null
+++ b/apps/governance/src/routes/proposals/components/protocol-upgrade-proposals-list-item/protocol-upgrade-proposals-list-item.tsx
@@ -0,0 +1,124 @@
+import { useTranslation } from 'react-i18next';
+import { Link } from 'react-router-dom';
+import {
+ Button,
+ Icon,
+ Intent,
+ Lozenge,
+ RoundedWrapper,
+} from '@vegaprotocol/ui-toolkit';
+import { stripFullStops } from '@vegaprotocol/utils';
+import { ProtocolUpgradeProposalStatus } from '@vegaprotocol/types';
+import { SubHeading } from '../../../../components/heading';
+import type { ReactNode } from 'react';
+import type { ProtocolUpgradeProposalFieldsFragment } from '../../protocol-upgrade/__generated__/ProtocolUpgradeProposals';
+import Routes from '../../../routes';
+
+interface ProtocolProposalsListItemProps {
+ proposal: ProtocolUpgradeProposalFieldsFragment;
+}
+
+export const ProtocolUpgradeProposalsListItem = ({
+ proposal,
+}: ProtocolProposalsListItemProps) => {
+ const { t } = useTranslation();
+ if (!proposal || !proposal.upgradeBlockHeight) return null;
+
+ let proposalStatusIcon: ReactNode;
+
+ switch (proposal.status) {
+ case ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_REJECTED:
+ proposalStatusIcon = (
+
+
+ );
+ break;
+ case ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_PENDING:
+ proposalStatusIcon = (
+
+
+ );
+ break;
+ case ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_APPROVED:
+ proposalStatusIcon = (
+
+
+ );
+ break;
+ case ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_UNSPECIFIED:
+ proposalStatusIcon = (
+
+
+ );
+ break;
+ }
+
+ return (
+
+
+
+
+
+
+
+ {t('networkUpgrade')}
+
+
+
+ {t('vegaReleaseTag')}
+ {proposal.vegaReleaseTag}
+
+
+
+ {t('upgradeBlockHeight')}
+ {proposal.upgradeBlockHeight}
+
+
+
+
+
+ {t(`${proposal.status}`)}
+ {proposalStatusIcon}
+
+
+
+
+
+ {t('View')}
+
+
+
+
+
+
+ );
+};
diff --git a/apps/governance/src/routes/proposals/proposals/proposals-container.tsx b/apps/governance/src/routes/proposals/proposals/proposals-container.tsx
index 5bc93df4e..4a92bd5d9 100644
--- a/apps/governance/src/routes/proposals/proposals/proposals-container.tsx
+++ b/apps/governance/src/routes/proposals/proposals/proposals-container.tsx
@@ -5,13 +5,18 @@ import { useTranslation } from 'react-i18next';
import { SplashLoader } from '../../../components/splash-loader';
import { ProposalsList } from '../components/proposals-list';
import { useProposalsQuery } from './__generated__/Proposals';
-import type { ProposalFieldsFragment } from './__generated__/Proposals';
-import type { NodeConnection, NodeEdge } from '@vegaprotocol/utils';
import { getNodes } from '@vegaprotocol/utils';
import flow from 'lodash/flow';
-import { ProposalState } from '@vegaprotocol/types';
+import {
+ ProposalState,
+ ProtocolUpgradeProposalStatus,
+} from '@vegaprotocol/types';
+import type { NodeConnection, NodeEdge } from '@vegaprotocol/utils';
+import type { ProposalFieldsFragment } from './__generated__/Proposals';
+import type { ProtocolUpgradeProposalFieldsFragment } from '../protocol-upgrade/__generated__/ProtocolUpgradeProposals';
import orderBy from 'lodash/orderBy';
+import { useProtocolUpgradesQuery } from '../protocol-upgrade/__generated__/ProtocolUpgradeProposals';
const orderByDate = (arr: ProposalFieldsFragment[]) =>
orderBy(
@@ -20,6 +25,15 @@ const orderByDate = (arr: ProposalFieldsFragment[]) =>
['desc', 'desc']
);
+const orderByUpgradeBlockHeight = (
+ arr: ProtocolUpgradeProposalFieldsFragment[]
+) =>
+ orderBy(
+ arr,
+ [(p) => p?.upgradeBlockHeight, (p) => p.vegaReleaseTag],
+ ['desc', 'desc']
+ );
+
export function getNotRejectedProposals(
data?: NodeConnection> | null
): T[] {
@@ -32,6 +46,21 @@ export function getNotRejectedProposals(
])(data);
}
+export function getNotRejectedProtocolUpgradeProposals<
+ T extends ProtocolUpgradeProposalFieldsFragment
+>(data?: NodeConnection> | null): T[] {
+ return flow([
+ (data) =>
+ getNodes(data, (p) =>
+ p
+ ? p.status !==
+ ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_REJECTED
+ : false
+ ),
+ orderByUpgradeBlockHeight,
+ ])(data);
+}
+
export const ProposalsContainer = () => {
const { t } = useTranslation();
const { data, loading, error } = useProposalsQuery({
@@ -40,6 +69,16 @@ export const ProposalsContainer = () => {
errorPolicy: 'ignore',
});
+ const {
+ data: protocolUpgradesData,
+ loading: protocolUpgradesLoading,
+ error: protocolUpgradesError,
+ } = useProtocolUpgradesQuery({
+ pollInterval: 5000,
+ fetchPolicy: 'network-only',
+ errorPolicy: 'ignore',
+ });
+
const proposals = useMemo(
() =>
getNotRejectedProposals(
@@ -48,15 +87,25 @@ export const ProposalsContainer = () => {
[data]
);
- if (error) {
+ const protocolUpgradeProposals = useMemo(
+ () =>
+ protocolUpgradesData
+ ? getNotRejectedProtocolUpgradeProposals(
+ protocolUpgradesData.protocolUpgradeProposals
+ )
+ : [],
+ [protocolUpgradesData]
+ );
+
+ if (error || protocolUpgradesError) {
return (
- {error.message}
+ {error?.message || protocolUpgradesError?.message}
);
}
- if (loading) {
+ if (loading || protocolUpgradesLoading) {
return (
, status: Types.ProtocolUpgradeProposalStatus };
+
+export type ProtocolUpgradesQueryVariables = Types.Exact<{ [key: string]: never; }>;
+
+
+export type ProtocolUpgradesQuery = { __typename?: 'Query', lastBlockHeight: string, protocolUpgradeProposals?: { __typename?: 'ProtocolUpgradeProposalConnection', edges?: Array<{ __typename?: 'ProtocolUpgradeProposalEdge', node: { __typename?: 'ProtocolUpgradeProposal', upgradeBlockHeight: string, vegaReleaseTag: string, approvers: Array, status: Types.ProtocolUpgradeProposalStatus } }> | null } | null };
+
+export const ProtocolUpgradeProposalFieldsFragmentDoc = gql`
+ fragment ProtocolUpgradeProposalFields on ProtocolUpgradeProposal {
+ upgradeBlockHeight
+ vegaReleaseTag
+ approvers
+ status
+}
+ `;
+export const ProtocolUpgradesDocument = gql`
+ query ProtocolUpgrades {
+ lastBlockHeight
+ protocolUpgradeProposals {
+ edges {
+ node {
+ ...ProtocolUpgradeProposalFields
+ }
+ }
+ }
+}
+ ${ProtocolUpgradeProposalFieldsFragmentDoc}`;
+
+/**
+ * __useProtocolUpgradesQuery__
+ *
+ * To run a query within a React component, call `useProtocolUpgradesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useProtocolUpgradesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useProtocolUpgradesQuery({
+ * variables: {
+ * },
+ * });
+ */
+export function useProtocolUpgradesQuery(baseOptions?: Apollo.QueryHookOptions) {
+ const options = {...defaultOptions, ...baseOptions}
+ return Apollo.useQuery(ProtocolUpgradesDocument, options);
+ }
+export function useProtocolUpgradesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions) {
+ const options = {...defaultOptions, ...baseOptions}
+ return Apollo.useLazyQuery(ProtocolUpgradesDocument, options);
+ }
+export type ProtocolUpgradesQueryHookResult = ReturnType;
+export type ProtocolUpgradesLazyQueryHookResult = ReturnType;
+export type ProtocolUpgradesQueryResult = Apollo.QueryResult;
\ No newline at end of file
diff --git a/apps/governance/src/routes/proposals/protocol-upgrade/index.tsx b/apps/governance/src/routes/proposals/protocol-upgrade/index.tsx
new file mode 100644
index 000000000..75513a25b
--- /dev/null
+++ b/apps/governance/src/routes/proposals/protocol-upgrade/index.tsx
@@ -0,0 +1 @@
+export { ProtocolUpgradeProposalContainer as default } from './protocol-upgrade-proposal-container';
diff --git a/apps/governance/src/routes/proposals/protocol-upgrade/protocol-upgrade-proposal-container.tsx b/apps/governance/src/routes/proposals/protocol-upgrade/protocol-upgrade-proposal-container.tsx
new file mode 100644
index 000000000..72b54e039
--- /dev/null
+++ b/apps/governance/src/routes/proposals/protocol-upgrade/protocol-upgrade-proposal-container.tsx
@@ -0,0 +1,78 @@
+import { useEffect, useMemo } from 'react';
+import { useParams } from 'react-router-dom';
+import { AsyncRenderer } from '@vegaprotocol/ui-toolkit';
+import { removePaginationWrapper, stripFullStops } from '@vegaprotocol/utils';
+import * as Schema from '@vegaprotocol/types';
+
+import { ProtocolUpgradeProposal } from './protocol-upgrade-proposal';
+import { ProposalNotFound } from '../components/proposal-not-found';
+import { useProtocolUpgradesQuery } from './__generated__/ProtocolUpgradeProposals';
+import { useNodesQuery } from '../../staking/home/__generated__/Nodes';
+import { useRefreshAfterEpoch } from '../../../hooks/use-refresh-after-epoch';
+
+export const ProtocolUpgradeProposalContainer = () => {
+ const params = useParams<{ proposalReleaseTag: string }>();
+
+ const { data, loading, error, refetch } = useProtocolUpgradesQuery({
+ fetchPolicy: 'network-only',
+ errorPolicy: 'ignore',
+ skip: !params.proposalReleaseTag,
+ });
+
+ useEffect(() => {
+ const interval = setInterval(refetch, 1000);
+ return () => clearInterval(interval);
+ }, [refetch]);
+
+ const {
+ data: nodesData,
+ error: nodesError,
+ loading: nodesLoading,
+ refetch: nodesRefetch,
+ } = useNodesQuery();
+
+ useRefreshAfterEpoch(nodesData?.epoch.timestamps.expiry, nodesRefetch);
+
+ const protocolUpgradeProposal = useMemo(() => {
+ if (!data?.protocolUpgradeProposals) return null;
+
+ const proposals = removePaginationWrapper(
+ data.protocolUpgradeProposals.edges
+ );
+
+ return proposals.find(
+ ({ vegaReleaseTag }) =>
+ params.proposalReleaseTag &&
+ params.proposalReleaseTag === stripFullStops(vegaReleaseTag)
+ );
+ }, [data, params.proposalReleaseTag]);
+
+ const consensusValidators = useMemo(() => {
+ if (!nodesData?.nodesConnection.edges) return null;
+
+ const nodes = removePaginationWrapper(nodesData.nodesConnection.edges);
+
+ return nodes.filter(
+ ({ rankingScore: { status } }) =>
+ status === Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT
+ );
+ }, [nodesData]);
+
+ return (
+
+ {protocolUpgradeProposal ? (
+
+ );
+};
diff --git a/apps/governance/src/routes/proposals/protocol-upgrade/protocol-upgrade-proposal.spec.tsx b/apps/governance/src/routes/proposals/protocol-upgrade/protocol-upgrade-proposal.spec.tsx
new file mode 100644
index 000000000..8e59e8b0d
--- /dev/null
+++ b/apps/governance/src/routes/proposals/protocol-upgrade/protocol-upgrade-proposal.spec.tsx
@@ -0,0 +1,134 @@
+import { render } from '@testing-library/react';
+import * as Schema from '@vegaprotocol/types';
+import {
+ ProtocolUpgradeProposal,
+ getConsensusApprovals,
+ getConsensusApprovalsVotingPower,
+ getConsensusApprovalsVotingPowerPercentage,
+} from './protocol-upgrade-proposal';
+import { ProtocolUpgradeProposalStatus } from '@vegaprotocol/types';
+import { getNormalisedVotingPower } from '../../staking/shared';
+import type { NodesFragmentFragment } from '../../staking/home/__generated__/Nodes';
+import type { ProtocolUpgradeProposalFieldsFragment } from './__generated__/ProtocolUpgradeProposals';
+
+const mockProposal: ProtocolUpgradeProposalFieldsFragment = {
+ vegaReleaseTag: 'v0.1.234',
+ status:
+ ProtocolUpgradeProposalStatus.PROTOCOL_UPGRADE_PROPOSAL_STATUS_PENDING,
+ upgradeBlockHeight: '12345',
+ approvers: [],
+};
+
+const mockConsensusValidators: NodesFragmentFragment[] = [
+ {
+ id: 'ccc022b7e63a4d0a6d3a193c3940c88574060e58a184964c994998d86835a1b4',
+ name: 'Marvin',
+ avatarUrl: 'https://upload.wikimedia.org/wikipedia/en/2/25/Marvin-TV-3.jpg',
+ pubkey: '6abc23391a9f888ab240415bf63d6844b03fc360be822f4a1d2cd832d87b2917',
+ stakedTotal: '14182454495731682635157',
+ stakedByOperator: '1000000000000000000000',
+ stakedByDelegates: '13182454495731682635157',
+ pendingStake: '0',
+ rankingScore: {
+ rankingScore: '0.67845061012234727427532760837568',
+ stakeScore: '0.3392701644525644',
+ performanceScore: '0.9998677767864936',
+ votingPower: '3500',
+ status: Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+ __typename: 'RankingScore',
+ },
+ __typename: 'Node',
+ },
+ {
+ id: 'ccc022b7e63a4d0a6d3a193c3940c88574060e58a184964c994998d86835a1b5',
+ name: 'Barvin',
+ avatarUrl: 'https://upload.wikimedia.org/wikipedia/en/2/25/Barvin-TV-3.jpg',
+ pubkey: '6abc23391a9f888ab240415bf63d6844b03fc360be822f4a1d2cd832d87b291b',
+ stakedTotal: '1418245449573168263',
+ stakedByOperator: '100000000000000000',
+ stakedByDelegates: '1318245449573168263',
+ pendingStake: '0',
+ rankingScore: {
+ rankingScore: '0.5',
+ stakeScore: '0.3',
+ performanceScore: '0.98',
+ votingPower: '2500',
+ status: Schema.ValidatorStatus.VALIDATOR_NODE_STATUS_TENDERMINT,
+ __typename: 'RankingScore',
+ },
+ __typename: 'Node',
+ },
+];
+
+const renderComponent = () =>
+ render(
+ (
+ (acc: number, curr: NodesFragmentFragment) => {
+ return acc + Number(curr.rankingScore.votingPower);
+ },
+ 0
+ );
+
+export const getConsensusApprovalsVotingPowerPercentage = (
+ consensusApprovalsVotingPower: number
+) =>
+ consensusApprovalsVotingPower > 0
+ ? getNormalisedVotingPower(consensusApprovalsVotingPower.toString(), 2)
+ : '0%';
+
+export const ProtocolUpgradeProposal = ({
+ proposal,
+ lastBlockHeight,
+ consensusValidators,
+}: ProtocolUpgradeProposalProps) => {
+ const consensusApprovals = useMemo(
+ () => getConsensusApprovals(consensusValidators || [], proposal),
+ [consensusValidators, proposal]
+ );
+
+ const consensusApprovalsVotingPower = useMemo(
+ () => getConsensusApprovalsVotingPower(consensusApprovals || []),
+ [consensusApprovals]
+ );
+
+ const consensusApprovalsVotingPowerPercentage = useMemo(
+ () =>
+ getConsensusApprovalsVotingPowerPercentage(consensusApprovalsVotingPower),
+ [consensusApprovalsVotingPower]
+ );
+
+ return (
+
+
+ );
+};
diff --git a/apps/governance/src/routes/router-config.tsx b/apps/governance/src/routes/router-config.tsx
index 1d457c761..bbea78836 100644
--- a/apps/governance/src/routes/router-config.tsx
+++ b/apps/governance/src/routes/router-config.tsx
@@ -109,6 +109,13 @@ const LazyProposal = React.lazy(
)
);
+const LazyProtocolUpgradeProposal = React.lazy(
+ () =>
+ import(
+ /* webpackChunkName: "route-governance-protocol-upgrade-proposal", webpackPrefetch: true */ './proposals/protocol-upgrade'
+ )
+);
+
const LazyProposalsList = React.lazy(
() =>
import(
@@ -257,6 +264,10 @@ const routerConfig = [
},
{ path: 'proposals', element:
- )}
- {name}
-