9619158732

Committed 21 Jun 2024 08:02PM UTC coverage: 14.891% (-0.004%) from 14.895%

Build # 9619158732

Build Type

Pull #8219

github

Committed by

web-flow

Commit Message

Merge c73f1bd55 into 3dc674aab

Pull Request Pull Request #8219: Rotate Alchemy Keys

Run Details

3634 of 23037 branches covered (15.77%)

Branch coverage included in aggregate %.

0 of 7 new or added lines in 1 file covered. (0.0%)

3516 existing lines in 313 files now uncovered.

4952 of 34622 relevant lines covered (14.3%)

4.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

1.49

/packages/commonwealth/server/controllers/server_proposals_controller.ts

import { AppError, ServerError } from '@hicommonwealth/core';
import { DB } from '@hicommonwealth/model';
import { ChainNetwork } from '@hicommonwealth/shared';
import { ethers, providers } from 'ethers';
import {
  GetProposalVotesOptions,
  GetProposalVotesResult,
  __getProposalVotes,
} from './server_proposal_methods/get_proposal_votes';
import {
  GetProposalsOptions,
  GetProposalsResult,
  __getProposals,
} from './server_proposal_methods/get_proposals';

export type SupportedProposalNetworks =
  | ChainNetwork.Aave
  | ChainNetwork.Compound;

export type ContractInfo = {
  address: string;
  type: SupportedProposalNetworks;
};

export class ServerProposalsController {
  constructor(public models: DB) {}

  public async getProposals(
    options: GetProposalsOptions,
  ): Promise<GetProposalsResult> {
    const contractInfo = await this.getContractInfo(options.communityId);
    const provider = await this.createEvmProvider(options.communityId);
    return __getProposals.call(
      this,
      options,
      provider,
      contractInfo,
      this.models,
    );
  }

  public async getProposalVotes(
    options: GetProposalVotesOptions,
  ): Promise<GetProposalVotesResult> {
    const contractInfo = await this.getContractInfo(options.communityId);
    const provider = await this.createEvmProvider(options.communityId);
    return __getProposalVotes.call(this, options, provider, contractInfo);
  }

  private async getContractInfo(communityId: string): Promise<ContractInfo> {
    const contract = await this.models.CommunityContract.findOne({
      where: {
        community_id: communityId,
      },
      attributes: [],
      include: [
        {
          model: this.models.Contract,
          required: true,
          attributes: ['address', 'type'],
        },
      ],
    });

    // @ts-expect-error StrictNullChecks
    if (!contract.Contract.address) {
      throw new ServerError(
        `No contract address found for community ${communityId}`,
      );
    }

    if (
      // @ts-expect-error StrictNullChecks
      !contract.Contract.type ||
      // @ts-expect-error StrictNullChecks
      (contract.Contract.type !== ChainNetwork.Aave &&
        // @ts-expect-error StrictNullChecks
        contract.Contract.type !== ChainNetwork.Compound)
    ) {
      throw new AppError(
        `Proposal fetching not supported for community ${communityId}`,
      );
    }

    return {
      // @ts-expect-error StrictNullChecks
      address: contract.Contract.address,
      // @ts-expect-error StrictNullChecks
      type: contract.Contract.type,
    };
  }

  private async createEvmProvider(
    communityId: string,
  ): Promise<providers.JsonRpcProvider> {
    const ethNetworkUrl = await this.getRPCUrl(communityId);

    if (ethNetworkUrl.slice(0, 4) != 'http')
      throw new ServerError(
        `Invalid ethNetworkUrl: ${ethNetworkUrl}. Must be an HTTP URL.`,
      );

    try {
      return new ethers.providers.JsonRpcProvider(ethNetworkUrl);
    } catch (e) {
      throw new ServerError(
        `Failed to create EVM provider for ${communityId}. ${e}`,
      );
    }
  }

  private async getRPCUrl(communityId: string): Promise<string> {
    const community = await this.models.Community.findOne({
      where: {
        id: communityId,
      },
      attributes: ['network', 'base'],
      include: [
        {
          model: this.models.ChainNode.scope('withPrivateData'),
          required: true,
        },
      ],
    });

    // @ts-expect-error StrictNullChecks
    if (!community.ChainNode.private_url && !community.ChainNode.url) {
      throw new ServerError(`No RPC URL found for community ${communityId}`);
    }

    // only Aave and Compound contracts on Ethereum are supported
    // Celo and Fantom public nodes are extremely slow/rate limited
    // so, it is not feasible to fetch proposals from them without
    // a private node, indexing the chain, or using an existing
    // indexer like TheGraph or SubQuery
    if (
      // @ts-expect-error StrictNullChecks
      community.ChainNode.name !== 'Ethereum (Mainnet)' ||
      // @ts-expect-error StrictNullChecks
      (community.network !== ChainNetwork.Aave &&
        // @ts-expect-error StrictNullChecks
        community.network !== ChainNetwork.Compound &&
        // @ts-expect-error StrictNullChecks
        community.base !== 'ethereum')
    ) {
      throw new AppError(
        `Proposal fetching not supported for community ${communityId}`,
      );
    }

    // @ts-expect-error StrictNullChecks
    return community.ChainNode.private_url || community.ChainNode.url;
  }
}

1	import { AppError, ServerError } from '@hicommonwealth/core';
2	import { DB } from '@hicommonwealth/model';
3	import { ChainNetwork } from '@hicommonwealth/shared';
4	import { ethers, providers } from 'ethers';
5	import {
6	GetProposalVotesOptions,
7	GetProposalVotesResult,
8	__getProposalVotes,
9	} from './server_proposal_methods/get_proposal_votes';
10	import {
11	GetProposalsOptions,
12	GetProposalsResult,
13	__getProposals,
14	} from './server_proposal_methods/get_proposals';
15
16	export type SupportedProposalNetworks =
17	\| ChainNetwork.Aave
18	\| ChainNetwork.Compound;
19
20	export type ContractInfo = {
21	address: string;
22	type: SupportedProposalNetworks;
23	};
24
25	export class ServerProposalsController {
UNCOV 26	constructor(public models: DB) {}	22✔
27
28	public async getProposals(
29	options: GetProposalsOptions,
30	): Promise<GetProposalsResult> {
31	const contractInfo = await this.getContractInfo(options.communityId);	×
32	const provider = await this.createEvmProvider(options.communityId);	×
33	return __getProposals.call(	×
34	this,
35	options,
36	provider,
37	contractInfo,
38	this.models,
39	);
40	}
41
42	public async getProposalVotes(
43	options: GetProposalVotesOptions,
44	): Promise<GetProposalVotesResult> {
45	const contractInfo = await this.getContractInfo(options.communityId);	×
46	const provider = await this.createEvmProvider(options.communityId);	×
47	return __getProposalVotes.call(this, options, provider, contractInfo);	×
48	}
49
50	private async getContractInfo(communityId: string): Promise<ContractInfo> {
51	const contract = await this.models.CommunityContract.findOne({	×
52	where: {
53	community_id: communityId,
54	},
55	attributes: [],
56	include: [
57	{
58	model: this.models.Contract,
59	required: true,
60	attributes: ['address', 'type'],
61	},
62	],
63	});
64
65	// @ts-expect-error StrictNullChecks
66	if (!contract.Contract.address) {	×
67	throw new ServerError(	×
68	`No contract address found for community ${communityId}`,
69	);
70	}
71
72	if (	×
73	// @ts-expect-error StrictNullChecks
74	!contract.Contract.type \|\|	×
75	// @ts-expect-error StrictNullChecks
76	(contract.Contract.type !== ChainNetwork.Aave &&
77	// @ts-expect-error StrictNullChecks
78	contract.Contract.type !== ChainNetwork.Compound)
79	) {
80	throw new AppError(	×
81	`Proposal fetching not supported for community ${communityId}`,
82	);
83	}
84
85	return {	×
86	// @ts-expect-error StrictNullChecks
87	address: contract.Contract.address,
88	// @ts-expect-error StrictNullChecks
89	type: contract.Contract.type,
90	};
91	}
92
93	private async createEvmProvider(
94	communityId: string,
95	): Promise<providers.JsonRpcProvider> {
96	const ethNetworkUrl = await this.getRPCUrl(communityId);	×
97
98	if (ethNetworkUrl.slice(0, 4) != 'http')	×
99	throw new ServerError(	×
100	`Invalid ethNetworkUrl: ${ethNetworkUrl}. Must be an HTTP URL.`,
101	);
102
103	try {	×
104	return new ethers.providers.JsonRpcProvider(ethNetworkUrl);	×
105	} catch (e) {
106	throw new ServerError(	×
107	`Failed to create EVM provider for ${communityId}. ${e}`,
108	);
109	}
110	}
111
112	private async getRPCUrl(communityId: string): Promise<string> {
113	const community = await this.models.Community.findOne({	×
114	where: {
115	id: communityId,
116	},
117	attributes: ['network', 'base'],
118	include: [
119	{
120	model: this.models.ChainNode.scope('withPrivateData'),
121	required: true,
122	},
123	],
124	});
125
126	// @ts-expect-error StrictNullChecks
127	if (!community.ChainNode.private_url && !community.ChainNode.url) {	×
128	throw new ServerError(`No RPC URL found for community ${communityId}`);	×
129	}
130
131	// only Aave and Compound contracts on Ethereum are supported
132	// Celo and Fantom public nodes are extremely slow/rate limited
133	// so, it is not feasible to fetch proposals from them without
134	// a private node, indexing the chain, or using an existing
135	// indexer like TheGraph or SubQuery
136	if (	×
137	// @ts-expect-error StrictNullChecks
138	community.ChainNode.name !== 'Ethereum (Mainnet)' \|\|	×
139	// @ts-expect-error StrictNullChecks
140	(community.network !== ChainNetwork.Aave &&
141	// @ts-expect-error StrictNullChecks
142	community.network !== ChainNetwork.Compound &&
143	// @ts-expect-error StrictNullChecks
144	community.base !== 'ethereum')
145	) {
146	throw new AppError(	×
147	`Proposal fetching not supported for community ${communityId}`,
148	);
149	}
150
151	// @ts-expect-error StrictNullChecks
152	return community.ChainNode.private_url \|\| community.ChainNode.url;	×
153	}
154	}

hicommonwealth / commonwealth / 9619158732

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous