11693012909

Committed 05 Nov 2024 09:43PM UTC coverage: 43.665% (-0.04%) from 43.707%

Build # 11693012909

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9817 from hicommonwealth/ryan/blacklist-events

Use blacklist instead of whitelist for events

Run Details

978 of 2583 branches covered (37.86%)

Branch coverage included in aggregate %.

1 of 1 new or added line in 1 file covered. (100.0%)

1 existing line in 1 file now uncovered.

2141 of 4560 relevant lines covered (46.95%)

22.67 hits per line

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

40.22

/libs/model/src/utils/utils.ts

import { blobStorage, EventPairs, logger } from '@hicommonwealth/core';
import {
  getThreadUrl,
  safeTruncateBody,
  type AbiType,
} from '@hicommonwealth/shared';
import { createHash } from 'crypto';
import { hasher } from 'node-object-hash';
import {
  Model,
  ModelStatic,
  QueryTypes,
  Sequelize,
  Transaction,
} from 'sequelize';
import { v4 as uuidv4 } from 'uuid';
import { isAddress } from 'web3-validator';
import { config } from '../config';
import type { OutboxAttributes } from '../models/outbox';

const log = logger(import.meta);

export function hashAbi(abi: AbiType): string {
  const hashInstance = hasher({
    coerce: true,
    sort: true,
    trim: true,
    alg: 'sha256',
    enc: 'hex',
  });
  return hashInstance.hash(abi);
}

/**
 * This functions takes either a new domain record or a pre-formatted event and inserts it into the Outbox. For core
 * domain events (e.g. new thread, new comment, etc.), the event_payload should be the complete domain record. The point
 * of this is that the emitter of a core domain event should never have to format the record itself. This
 * utility function centralizes event emission so that if any changes are required to the Outbox table or emission of
 * a specific event, this function can be updated without having to update the emitter code.
 */
export async function emitEvent(
  outbox: ModelStatic<Model<OutboxAttributes>>,
  values: Array<EventPairs>,
  transaction?: Transaction | null,
) {
  const records: Array<EventPairs> = [];
  for (const event of values) {
    if (!config.OUTBOX.BLACKLISTED_EVENTS.includes(event.event_name)) {
      records.push(event);
    } else {
      log.warn(
        `Event not inserted into outbox! ` +
          `The event "${event.event_name}" is blacklisted. Remove it from BLACKLISTED_EVENTS env in order to allow emitting this event.`,
        {
          event_name: event.event_name,
          allowed_events: config.OUTBOX.BLACKLISTED_EVENTS,
        },
      );
    }
  }

  if (records.length > 0) {
    await outbox.bulkCreate(values, { transaction });
  }
}

export function buildThreadContentUrl(communityId: string, threadId: number) {
  const fullContentUrl = getThreadUrl({
    chain: communityId,
    id: threadId,
  });
  // content url only contains path
  return new URL(fullContentUrl).pathname;
}

// returns community ID and thread ID from content url
export function decodeThreadContentUrl(contentUrl: string): {
  communityId: string | null;
  threadId: number | null;
} {
  if (contentUrl.startsWith('/farcaster/')) {
    return {
      communityId: null,
      threadId: null,
    };
  }
  if (!contentUrl.includes('/discussion/')) {
    throw new Error(`invalid content url: ${contentUrl}`);
  }
  const [communityId, threadId] = contentUrl
    .split('/discussion/')
    .map((part) => part.replaceAll('/', ''));
  return {
    communityId,
    threadId: parseInt(threadId, 10),
  };
}

/**
 * Checks whether two Ethereum addresses are equal. Throws if a provided string is not a valid EVM address.
 * Address comparison is done in lowercase to ensure case insensitivity.
 * @param address1 - The first Ethereum address.
 * @param address2 - The second Ethereum address.
 * @returns True if the strings are equal, valid EVM addresses - false otherwise.
 */
export function equalEvmAddresses(
  address1: string | unknown,
  address2: string | unknown,
): boolean {
  const isRealAddress = (address: string | unknown) => {
    if (!address || typeof address !== 'string' || !isAddress(address)) {
      throw new Error(`Invalid address ${address}`);
    }
    return address;
  };

  const validAddress1 = isRealAddress(address1);
  const validAddress2 = isRealAddress(address2);

  // Convert addresses to lowercase and compare
  const normalizedAddress1 = validAddress1.toLowerCase();
  const normalizedAddress2 = validAddress2.toLowerCase();

  return normalizedAddress1 === normalizedAddress2;
}

/**
 * Returns all contest managers associated with a thread by topic and community
 * @param sequelize - The sequelize instance
 * @param topicId - The topic ID of the thread
 * @param communityId - the community ID of the thread
 * @returns array of contest manager
 */
export async function getThreadContestManagers(
  sequelize: Sequelize,
  topicId: number,
  communityId: string,
): Promise<
  {
    contest_address: string;
  }[]
> {
  const contestManagers = await sequelize.query<{
    contest_address: string;
  }>(
    `
        SELECT cm.contest_address, cm.cancelled, cm.ended
        FROM "Communities" c
                 JOIN "ContestManagers" cm ON cm.community_id = c.id
                 JOIN "ContestTopics" ct ON cm.contest_address = ct.contest_address
        WHERE ct.topic_id = :topic_id
          AND cm.community_id = :community_id
          AND cm.cancelled IS NOT TRUE
          AND cm.ended IS NOT TRUE
    `,
    {
      type: QueryTypes.SELECT,
      replacements: {
        topic_id: topicId,
        community_id: communityId,
      },
    },
  );
  return contestManagers;
}

export function removeUndefined(
  obj: Record<string, string | number | undefined>,
) {
  const result: Record<string, string | number | undefined> = {};

  Object.keys(obj).forEach((key) => {
    if (obj[key] !== undefined) {
      result[key as string] = obj[key];
    }
  });

  return result;
}

const alchemyUrlPattern = /^https:\/\/[a-z]+-[a-z]+\.g\.alchemy\.com\/v2\//;

export function buildChainNodeUrl(url: string, privacy: 'private' | 'public') {
  if (url === '') return url;

  if (alchemyUrlPattern.test(url)) {
    const [baseUrl, key] = url.split('/v2/');
    if (key === config.ALCHEMY.APP_KEYS.PRIVATE && privacy !== 'private')
      return `${baseUrl}/v2/${config.ALCHEMY.APP_KEYS.PUBLIC}`;
    else if (key === config.ALCHEMY.APP_KEYS.PUBLIC && privacy !== 'public')
      return `${baseUrl}/v2/${config.ALCHEMY.APP_KEYS.PRIVATE}`;
    else if (key === '')
      return (
        url +
        (privacy === 'private'
          ? config.ALCHEMY.APP_KEYS.PRIVATE
          : config.ALCHEMY.APP_KEYS.PUBLIC)
      );
  }
  return url;
}

export function getChainNodeUrl({
  url,
  private_url,
}: {
  url: string;
  private_url?: string;
}) {
  if (!private_url || private_url === '')
    return buildChainNodeUrl(url, 'public');
  return buildChainNodeUrl(private_url, 'private');
}

export const R2_ADAPTER_KEY = 'blobStorageFactory.R2BlobStorage.Main';

/**
 * Limits content in the Threads.body and Comments.text columns to 2k characters (2kB)
 * Anything over this character limit is stored in Cloudflare R2.
 * 55% of threads and 90% of comments are shorter than this.
 * Anything over 2kB is TOASTed by Postgres so this limit prevents TOAST.
 */
const CONTENT_CHAR_LIMIT = 2_000;

/**
 * Uploads content to the appropriate R2 bucket if the content exceeds the
 * preview limit (CONTENT_CHAR_LIMIT),
 */
export async function uploadIfLarge(
  type: 'threads' | 'comments',
  content: string,
): Promise<{
  contentUrl: string | null;
  truncatedBody: string | null;
}> {
  if (content.length > CONTENT_CHAR_LIMIT) {
    const { url } = await blobStorage({
      key: R2_ADAPTER_KEY,
    }).upload({
      key: `${uuidv4()}.md`,
      bucket: type,
      content: content,
      contentType: 'text/markdown',
    });
    return { contentUrl: url, truncatedBody: safeTruncateBody(content, 500) };
  } else return { contentUrl: null, truncatedBody: null };
}

export function getSaltedApiKeyHash(apiKey: string, salt: string): string {
  return createHash('sha256')
    .update(apiKey + salt)
    .digest('hex');
}

export function buildApiKeySaltCacheKey(address: string) {
  return `salt_${address.toLowerCase()}`;
}

1	import { blobStorage, EventPairs, logger } from '@hicommonwealth/core';
2	import {
3	getThreadUrl,
4	safeTruncateBody,
5	type AbiType,
6	} from '@hicommonwealth/shared';
7	import { createHash } from 'crypto';
8	import { hasher } from 'node-object-hash';
9	import {
10	Model,
11	ModelStatic,
12	QueryTypes,
13	Sequelize,
14	Transaction,
15	} from 'sequelize';
16	import { v4 as uuidv4 } from 'uuid';
17	import { isAddress } from 'web3-validator';
18	import { config } from '../config';
19	import type { OutboxAttributes } from '../models/outbox';
20
21	const log = logger(import.meta);	26✔
22
23	export function hashAbi(abi: AbiType): string {
24	const hashInstance = hasher({	×
25	coerce: true,
26	sort: true,
27	trim: true,
28	alg: 'sha256',
29	enc: 'hex',
30	});
31	return hashInstance.hash(abi);	×
32	}
33
34	/**
35	* This functions takes either a new domain record or a pre-formatted event and inserts it into the Outbox. For core
36	* domain events (e.g. new thread, new comment, etc.), the event_payload should be the complete domain record. The point
37	* of this is that the emitter of a core domain event should never have to format the record itself. This
38	* utility function centralizes event emission so that if any changes are required to the Outbox table or emission of
39	* a specific event, this function can be updated without having to update the emitter code.
40	*/
41	export async function emitEvent(
42	outbox: ModelStatic<Model<OutboxAttributes>>,
43	values: Array<EventPairs>,
44	transaction?: Transaction \| null,
45	) {
46	const records: Array<EventPairs> = [];	55✔
47	for (const event of values) {	55✔
48	if (!config.OUTBOX.BLACKLISTED_EVENTS.includes(event.event_name)) {	55!
49	records.push(event);	55✔
50	} else {
UNCOV 51	log.warn(	×
52	`Event not inserted into outbox! ` +
53	`The event "${event.event_name}" is blacklisted. Remove it from BLACKLISTED_EVENTS env in order to allow emitting this event.`,
54	{
55	event_name: event.event_name,
56	allowed_events: config.OUTBOX.BLACKLISTED_EVENTS,
57	},
58	);
59	}
60	}
61
62	if (records.length > 0) {	55!
63	await outbox.bulkCreate(values, { transaction });	55✔
64	}
65	}
66
67	export function buildThreadContentUrl(communityId: string, threadId: number) {
68	const fullContentUrl = getThreadUrl({	×
69	chain: communityId,
70	id: threadId,
71	});
72	// content url only contains path
73	return new URL(fullContentUrl).pathname;	×
74	}
75
76	// returns community ID and thread ID from content url
77	export function decodeThreadContentUrl(contentUrl: string): {
78	communityId: string \| null;
79	threadId: number \| null;
80	} {
81	if (contentUrl.startsWith('/farcaster/')) {	2!
82	return {	×
83	communityId: null,
84	threadId: null,
85	};
86	}
87	if (!contentUrl.includes('/discussion/')) {	2!
88	throw new Error(`invalid content url: ${contentUrl}`);	×
89	}
90	const [communityId, threadId] = contentUrl	2✔
91	.split('/discussion/')
92	.map((part) => part.replaceAll('/', ''));	4✔
93	return {	2✔
94	communityId,
95	threadId: parseInt(threadId, 10),
96	};
97	}
98
99	/**
100	* Checks whether two Ethereum addresses are equal. Throws if a provided string is not a valid EVM address.
101	* Address comparison is done in lowercase to ensure case insensitivity.
102	* @param address1 - The first Ethereum address.
103	* @param address2 - The second Ethereum address.
104	* @returns True if the strings are equal, valid EVM addresses - false otherwise.
105	*/
106	export function equalEvmAddresses(
107	address1: string \| unknown,
108	address2: string \| unknown,
109	): boolean {
110	const isRealAddress = (address: string \| unknown) => {	×
111	if (!address \|\| typeof address !== 'string' \|\| !isAddress(address)) {	×
112	throw new Error(`Invalid address ${address}`);	×
113	}
114	return address;	×
115	};
116
117	const validAddress1 = isRealAddress(address1);	×
118	const validAddress2 = isRealAddress(address2);	×
119
120	// Convert addresses to lowercase and compare
121	const normalizedAddress1 = validAddress1.toLowerCase();	×
122	const normalizedAddress2 = validAddress2.toLowerCase();	×
123
124	return normalizedAddress1 === normalizedAddress2;	×
125	}
126
127	/**
128	* Returns all contest managers associated with a thread by topic and community
129	* @param sequelize - The sequelize instance
130	* @param topicId - The topic ID of the thread
131	* @param communityId - the community ID of the thread
132	* @returns array of contest manager
133	*/
134	export async function getThreadContestManagers(
135	sequelize: Sequelize,
136	topicId: number,
137	communityId: string,
138	): Promise<
139	{
140	contest_address: string;
141	}[]
142	> {
143	const contestManagers = await sequelize.query<{	13✔
144	contest_address: string;
145	}>(
146	`
147	SELECT cm.contest_address, cm.cancelled, cm.ended
148	FROM "Communities" c
149	JOIN "ContestManagers" cm ON cm.community_id = c.id
150	JOIN "ContestTopics" ct ON cm.contest_address = ct.contest_address
151	WHERE ct.topic_id = :topic_id
152	AND cm.community_id = :community_id
153	AND cm.cancelled IS NOT TRUE
154	AND cm.ended IS NOT TRUE
155	`,
156	{
157	type: QueryTypes.SELECT,
158	replacements: {
159	topic_id: topicId,
160	community_id: communityId,
161	},
162	},
163	);
164	return contestManagers;	13✔
165	}
166
167	export function removeUndefined(
168	obj: Record<string, string \| number \| undefined>,
169	) {
170	const result: Record<string, string \| number \| undefined> = {};	×
171
172	Object.keys(obj).forEach((key) => {	×
173	if (obj[key] !== undefined) {	×
174	result[key as string] = obj[key];	×
175	}
176	});
177
178	return result;	×
179	}
180
181	const alchemyUrlPattern = /^https:\/\/[a-z]+-[a-z]+\.g\.alchemy\.com\/v2\//;	26✔
182
183	export function buildChainNodeUrl(url: string, privacy: 'private' \| 'public') {
184	if (url === '') return url;	40!
185
186	if (alchemyUrlPattern.test(url)) {	40!
187	const [baseUrl, key] = url.split('/v2/');	×
188	if (key === config.ALCHEMY.APP_KEYS.PRIVATE && privacy !== 'private')	×
189	return `${baseUrl}/v2/${config.ALCHEMY.APP_KEYS.PUBLIC}`;	×
190	else if (key === config.ALCHEMY.APP_KEYS.PUBLIC && privacy !== 'public')	×
191	return `${baseUrl}/v2/${config.ALCHEMY.APP_KEYS.PRIVATE}`;	×
192	else if (key === '')
193	return (	×
194	url +
195	(privacy === 'private'	×
196	? config.ALCHEMY.APP_KEYS.PRIVATE
197	: config.ALCHEMY.APP_KEYS.PUBLIC)
198	);
199	}
200	return url;	40✔
201	}
202
203	export function getChainNodeUrl({
204	url,
205	private_url,
206	}: {
207	url: string;
208	private_url?: string;
209	}) {
210	if (!private_url \|\| private_url === '')	3!
211	return buildChainNodeUrl(url, 'public');	×
212	return buildChainNodeUrl(private_url, 'private');	3✔
213	}
214
215	export const R2_ADAPTER_KEY = 'blobStorageFactory.R2BlobStorage.Main';	26✔
216
217	/**
218	* Limits content in the Threads.body and Comments.text columns to 2k characters (2kB)
219	* Anything over this character limit is stored in Cloudflare R2.
220	* 55% of threads and 90% of comments are shorter than this.
221	* Anything over 2kB is TOASTed by Postgres so this limit prevents TOAST.
222	*/
223	const CONTENT_CHAR_LIMIT = 2_000;	26✔
224
225	/**
226	* Uploads content to the appropriate R2 bucket if the content exceeds the
227	* preview limit (CONTENT_CHAR_LIMIT),
228	*/
229	export async function uploadIfLarge(
230	type: 'threads' \| 'comments',
231	content: string,
232	): Promise<{
233	contentUrl: string \| null;
234	truncatedBody: string \| null;
235	}> {
236	if (content.length > CONTENT_CHAR_LIMIT) {	24✔
237	const { url } = await blobStorage({	5✔
238	key: R2_ADAPTER_KEY,
239	}).upload({
240	key: `${uuidv4()}.md`,
241	bucket: type,
242	content: content,
243	contentType: 'text/markdown',
244	});
245	return { contentUrl: url, truncatedBody: safeTruncateBody(content, 500) };	5✔
246	} else return { contentUrl: null, truncatedBody: null };	19✔
247	}
248
249	export function getSaltedApiKeyHash(apiKey: string, salt: string): string {
250	return createHash('sha256')	×
251	.update(apiKey + salt)
252	.digest('hex');
253	}
254
255	export function buildApiKeySaltCacheKey(address: string) {
256	return `salt_${address.toLowerCase()}`;	×
257	}

hicommonwealth / commonwealth / 11693012909

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