9551722483

Committed 17 Jun 2024 05:01PM UTC coverage: 1.12% (-11.7%) from 12.845%

Build # 9551722483

Build Type

Pull #8160

github

Committed by

web-flow

Commit Message

Merge 15a526b3b into ea44a68a7

Pull Request Pull Request #8160: Delete legacy notifications

Run Details

142 of 17269 branches covered (0.82%)

Branch coverage included in aggregate %.

0 of 13 new or added lines in 3 files covered. (0.0%)

2941 existing lines in 313 files now uncovered.

392 of 30389 relevant lines covered (1.29%)

0.04 hits per line

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

0.0

/packages/commonwealth/server/routes/verifyAddress.ts

import { Op } from 'sequelize';
import { fileURLToPath } from 'url';

import { AppError, logger } from '@hicommonwealth/core';
import type {
  CommunityInstance,
  DB,
  ProfileAttributes,
} from '@hicommonwealth/model';
import {
  ChainBase,
  DynamicTemplate,
  NotificationCategories,
  WalletId,
  WalletSsoSource,
} from '@hicommonwealth/shared';
import sgMail from '@sendgrid/mail';
import type { NextFunction, Request, Response } from 'express';
import { MixpanelLoginEvent } from '../../shared/analytics/types';
import { addressSwapper } from '../../shared/utils';
import { ServerAnalyticsController } from '../controllers/server_analytics_controller';
import assertAddressOwnership from '../util/assertAddressOwnership';
import verifySessionSignature from '../util/verifySessionSignature';

const __filename = fileURLToPath(import.meta.url);
const log = logger(__filename);

export const Errors = {
  NoChain: 'Must provide chain',
  InvalidCommunity: 'Invalid community',
  AddressNF: 'Address not found',
  ExpiredToken: 'Token has expired, please re-register',
  InvalidSignature: 'Invalid signature, please re-register',
  NoEmail: 'No email to alert',
  InvalidArguments: 'Invalid arguments',
  CouldNotVerifySignature: 'Failed to verify signature',
  BadSecret: 'Invalid jwt secret',
  BadToken: 'Invalid sign in token',
  WrongWallet: 'Verified with different wallet than created',
};

const processAddress = async (
  models: DB,
  community: CommunityInstance,
  chain_id: string | number,
  address: string,
  wallet_id: WalletId,
  wallet_sso_source: WalletSsoSource,
  signature: string,
  user: Express.User,
  sessionAddress: string | null,
  sessionIssued: string | null,
  sessionBlockInfo: string | null,
): Promise<void> => {
  const addressInstance = await models.Address.scope('withPrivateData').findOne(
    {
      where: { community_id: community.id, address },
    },
  );
  if (!addressInstance) {
    throw new AppError(Errors.AddressNF);
  }

  if (addressInstance.wallet_id !== wallet_id) {
    throw new AppError(Errors.WrongWallet);
  }

  // check whether the token has expired
  // (certain login methods e.g. jwt have no expiration token, so we skip the check in that case)
  const expiration = addressInstance.verification_token_expires;
  if (expiration && +expiration <= +new Date()) {
    throw new AppError(Errors.ExpiredToken);
  }

  // verify the signature matches the session information = verify ownership
  try {
    const valid = await verifySessionSignature(
      models,
      community,
      chain_id,
      addressInstance,
      // @ts-expect-error StrictNullChecks
      user ? user.id : null,
      signature,
      sessionAddress,
      sessionIssued,
      sessionBlockInfo,
    );
    if (!valid) {
      throw new AppError(Errors.InvalidSignature);
    }
  } catch (e) {
    log.warn(`Failed to verify signature for ${address}: ${e.stack}`);
    throw new AppError(Errors.CouldNotVerifySignature);
  }

  addressInstance.last_active = new Date();

  if (!user?.id) {
    // user is not logged in
    // @ts-expect-error StrictNullChecks
    addressInstance.verification_token_expires = null;
    addressInstance.verified = new Date();
    if (!addressInstance.user_id) {
      // address is not yet verified => create a new user
      // @ts-expect-error StrictNullChecks
      const newUser = await models.User.createWithProfile({
        email: null,
      });
      addressInstance.profile_id = // @ts-expect-error StrictNullChecks
        (newUser.Profiles[0] as ProfileAttributes).id;
      await models.Subscription.create({
        // @ts-expect-error StrictNullChecks
        subscriber_id: newUser.id,
        category_id: NotificationCategories.NewMention,
        is_active: true,
      });
      await models.Subscription.create({
        // @ts-expect-error StrictNullChecks
        subscriber_id: newUser.id,
        category_id: NotificationCategories.NewCollaboration,
        is_active: true,
      });
      addressInstance.user_id = newUser.id;
    }
  } else {
    // user is already logged in => verify the newly created address
    // @ts-expect-error StrictNullChecks
    addressInstance.verification_token_expires = null;
    addressInstance.verified = new Date();
    addressInstance.user_id = user.id;
    const profile = await models.Profile.findOne({
      where: { user_id: user.id },
    });
    // @ts-expect-error StrictNullChecks
    addressInstance.profile_id = profile.id;
  }
  await addressInstance.save();

  // if address has already been previously verified, update all other addresses
  // to point to the new user = "transfer ownership".
  const addressToTransfer = await models.Address.findOne({
    // @ts-expect-error StrictNullChecks
    where: {
      address,
      user_id: { [Op.ne]: addressInstance.user_id },
      verified: { [Op.ne]: null },
    },
  });

  if (addressToTransfer) {
    // reassign the users and profiles of the transferred addresses
    await models.Address.update(
      {
        user_id: addressInstance.user_id,
        profile_id: addressInstance.profile_id,
      },
      {
        // @ts-expect-error StrictNullChecks
        where: {
          address,
          user_id: { [Op.ne]: addressInstance.user_id },
          verified: { [Op.ne]: null },
        },
      },
    );

    try {
      // send email to the old user (should only ever be one)
      const oldUser = await models.User.scope('withPrivateData').findOne({
        where: { id: addressToTransfer.user_id, email: { [Op.ne]: null } },
      });
      if (!oldUser?.email) {
        throw new AppError(Errors.NoEmail);
      }
      const msg = {
        to: user.email,
        from: 'Commonwealth <no-reply@commonwealth.im>',
        templateId: DynamicTemplate.VerifyAddress,
        dynamic_template_data: {
          address,
          chain: community.name,
        },
      };
      // @ts-expect-error StrictNullChecks
      await sgMail.send(msg);
      log.info(
        `Sent address move email: ${address} transferred to a new account`,
      );
    } catch (e) {
      log.error(`Could not send address move email for: ${address}`);
    }
  }
};

const verifyAddress = async (
  models: DB,
  req: Request,
  res: Response,
  next: NextFunction,
) => {
  if (!req.body.community_id || !req.body.chain_id) {
    throw new AppError(Errors.NoChain);
  }
  const community = await models.Community.findOne({
    where: { id: req.body.community_id },
  });
  const chain_id = req.body.chain_id;
  if (!community) {
    return next(new AppError(Errors.InvalidCommunity));
  }

  if (!req.body.address || !req.body.signature) {
    throw new AppError(Errors.InvalidArguments);
  }

  const address =
    community.base === ChainBase.Substrate
      ? addressSwapper({
          address: req.body.address,
          // @ts-expect-error StrictNullChecks
          currentPrefix: community.ss58_prefix,
        })
      : req.body.address;

  await processAddress(
    models,
    community,
    chain_id,
    address,
    req.body.wallet_id,
    req.body.wallet_sso_source,
    req.body.signature,
    // @ts-expect-error StrictNullChecks
    req.user,
    req.body.session_public_address,
    req.body.session_timestamp || null, // disallow empty strings
    req.body.session_block_data || null, // disallow empty strings
  );

  // assertion check
  await assertAddressOwnership(models, address);

  if (req.user) {
    // if user was already logged in, we're done
    return res.json({
      status: 'Success',
      result: { address, message: 'Verified signature' },
    });
  } else {
    // if user isn't logged in, log them in now
    const newAddress = await models.Address.findOne({
      where: { community_id: req.body.community_id, address },
    });
    const user = await models.User.scope('withPrivateData').findOne({
      // @ts-expect-error StrictNullChecks
      where: { id: newAddress.user_id },
    });
    // @ts-expect-error StrictNullChecks
    req.login(user, (err) => {
      const serverAnalyticsController = new ServerAnalyticsController();
      if (err) {
        serverAnalyticsController.track(
          {
            event: MixpanelLoginEvent.LOGIN_FAILED,
          },
          req,
        );
        return next(err);
      }
      serverAnalyticsController.track(
        {
          event: MixpanelLoginEvent.LOGIN_COMPLETED,
          // @ts-expect-error StrictNullChecks
          userId: user.id,
        },
        req,
      );

      return res.json({
        status: 'Success',
        result: {
          user,
          address,
          message: 'Signed in',
        },
      });
    });
  }
};

export default verifyAddress;

1	import { Op } from 'sequelize';
2	import { fileURLToPath } from 'url';
3
4	import { AppError, logger } from '@hicommonwealth/core';
5	import type {
6	CommunityInstance,
7	DB,
8	ProfileAttributes,
9	} from '@hicommonwealth/model';
10	import {
11	ChainBase,
12	DynamicTemplate,
13	NotificationCategories,
14	WalletId,
15	WalletSsoSource,
16	} from '@hicommonwealth/shared';
17	import sgMail from '@sendgrid/mail';
18	import type { NextFunction, Request, Response } from 'express';
19	import { MixpanelLoginEvent } from '../../shared/analytics/types';
20	import { addressSwapper } from '../../shared/utils';
21	import { ServerAnalyticsController } from '../controllers/server_analytics_controller';
22	import assertAddressOwnership from '../util/assertAddressOwnership';
23	import verifySessionSignature from '../util/verifySessionSignature';
24
UNCOV 25	const __filename = fileURLToPath(import.meta.url);	×
26	const log = logger(__filename);
27
28	export const Errors = {
29	NoChain: 'Must provide chain',
30	InvalidCommunity: 'Invalid community',
31	AddressNF: 'Address not found',
32	ExpiredToken: 'Token has expired, please re-register',
33	InvalidSignature: 'Invalid signature, please re-register',
34	NoEmail: 'No email to alert',
35	InvalidArguments: 'Invalid arguments',
36	CouldNotVerifySignature: 'Failed to verify signature',
37	BadSecret: 'Invalid jwt secret',
38	BadToken: 'Invalid sign in token',
39	WrongWallet: 'Verified with different wallet than created',
40	};
41
42	const processAddress = async (
43	models: DB,
44	community: CommunityInstance,
45	chain_id: string \| number,
46	address: string,
47	wallet_id: WalletId,
48	wallet_sso_source: WalletSsoSource,
49	signature: string,
50	user: Express.User,
51	sessionAddress: string \| null,
52	sessionIssued: string \| null,
53	sessionBlockInfo: string \| null,
54	): Promise<void> => {
55	const addressInstance = await models.Address.scope('withPrivateData').findOne(
56	{
57	where: { community_id: community.id, address },
58	},
59	);	×
60	if (!addressInstance) {	×
61	throw new AppError(Errors.AddressNF);
62	}
63		×
64	if (addressInstance.wallet_id !== wallet_id) {	×
65	throw new AppError(Errors.WrongWallet);
66	}
67
68	// check whether the token has expired
69	// (certain login methods e.g. jwt have no expiration token, so we skip the check in that case)
UNCOV 70	const expiration = addressInstance.verification_token_expires;	×
71	if (expiration && +expiration <= +new Date()) {	×
72	throw new AppError(Errors.ExpiredToken);
73	}
74
75	// verify the signature matches the session information = verify ownership
UNCOV 76	try {	×
77	const valid = await verifySessionSignature(
78	models,
79	community,
80	chain_id,
81	addressInstance,
82	// @ts-expect-error StrictNullChecks	×
83	user ? user.id : null,	×
84	signature,
85	sessionAddress,
86	sessionIssued,
87	sessionBlockInfo,
88	);	×
89	if (!valid) {	×
90	throw new AppError(Errors.InvalidSignature);
91	}
92	} catch (e) {
93	log.warn(`Failed to verify signature for ${address}: ${e.stack}`);	×
94	throw new AppError(Errors.CouldNotVerifySignature);
95	}
96
97	addressInstance.last_active = new Date();
98		×
99	if (!user?.id) {	×
100	// user is not logged in
101	// @ts-expect-error StrictNullChecks
UNCOV 102	addressInstance.verification_token_expires = null;	×
UNCOV 103	addressInstance.verified = new Date();	×
104	if (!addressInstance.user_id) {	×
105	// address is not yet verified => create a new user
106	// @ts-expect-error StrictNullChecks
107	const newUser = await models.User.createWithProfile({
108	email: null,
109	});
110	addressInstance.profile_id = // @ts-expect-error StrictNullChecks
111	(newUser.Profiles[0] as ProfileAttributes).id;
112	await models.Subscription.create({
113	// @ts-expect-error StrictNullChecks
114	subscriber_id: newUser.id,
115	category_id: NotificationCategories.NewMention,
116	is_active: true,
117	});
118	await models.Subscription.create({	×
119	// @ts-expect-error StrictNullChecks
120	subscriber_id: newUser.id,
121	category_id: NotificationCategories.NewCollaboration,
122	is_active: true,
123	});
124	addressInstance.user_id = newUser.id;
125	}
126	} else {
127	// user is already logged in => verify the newly created address
128	// @ts-expect-error StrictNullChecks
UNCOV 129	addressInstance.verification_token_expires = null;	×
130	addressInstance.verified = new Date();
131	addressInstance.user_id = user.id;
132	const profile = await models.Profile.findOne({
133	where: { user_id: user.id },
134	});
135	// @ts-expect-error StrictNullChecks
136	addressInstance.profile_id = profile.id;
137	}
UNCOV 138	await addressInstance.save();	×
139
140	// if address has already been previously verified, update all other addresses
141	// to point to the new user = "transfer ownership".
142	const addressToTransfer = await models.Address.findOne({
143	// @ts-expect-error StrictNullChecks
144	where: {
145	address,
146	user_id: { [Op.ne]: addressInstance.user_id },
147	verified: { [Op.ne]: null },
148	},
149	});
150
151	if (addressToTransfer) {	×
152	// reassign the users and profiles of the transferred addresses
153	await models.Address.update(
154	{
155	user_id: addressInstance.user_id,
156	profile_id: addressInstance.profile_id,
157	},
158	{
159	// @ts-expect-error StrictNullChecks
160	where: {	×
161	address,
162	user_id: { [Op.ne]: addressInstance.user_id },
163	verified: { [Op.ne]: null },
164	},
165	},
166	);
167
168	try {
169	// send email to the old user (should only ever be one)
170	const oldUser = await models.User.scope('withPrivateData').findOne({
171	where: { id: addressToTransfer.user_id, email: { [Op.ne]: null } },
172	});
173	if (!oldUser?.email) {	×
174	throw new AppError(Errors.NoEmail);	×
175	}
176	const msg = {
177	to: user.email,
178	from: 'Commonwealth <no-reply@commonwealth.im>',
179	templateId: DynamicTemplate.VerifyAddress,
180	dynamic_template_data: {
181	address,
182	chain: community.name,
183	},
184	};
185	// @ts-expect-error StrictNullChecks
186	await sgMail.send(msg);
187	log.info(
188	`Sent address move email: ${address} transferred to a new account`,
189	);	×
190	} catch (e) {
191	log.error(`Could not send address move email for: ${address}`);
192	}
193	}
194	};
195
UNCOV 196	const verifyAddress = async (	×
197	models: DB,
198	req: Request,
199	res: Response,
200	next: NextFunction,	×
201	) => {
202	if (!req.body.community_id \|\| !req.body.chain_id) {	×
203	throw new AppError(Errors.NoChain);
204	}
UNCOV 205	const community = await models.Community.findOne({	×
206	where: { id: req.body.community_id },
207	});
208	const chain_id = req.body.chain_id;
209	if (!community) {	×
210	return next(new AppError(Errors.InvalidCommunity));
211	}
212
UNCOV 213	if (!req.body.address \|\| !req.body.signature) {	×
214	throw new AppError(Errors.InvalidArguments);
215	}
216
217	const address =
218	community.base === ChainBase.Substrate	×
219	? addressSwapper({
220	address: req.body.address,
221	// @ts-expect-error StrictNullChecks
222	currentPrefix: community.ss58_prefix,
223	})
224	: req.body.address;	×
225		×
226	await processAddress(
227	models,
228	community,
229	chain_id,
230	address,
231	req.body.wallet_id,	×
232	req.body.wallet_sso_source,
233	req.body.signature,
234	// @ts-expect-error StrictNullChecks
235	req.user,
236	req.body.session_public_address,
237	req.body.session_timestamp \|\| null, // disallow empty strings	×
238	req.body.session_block_data \|\| null, // disallow empty strings	×
239	);
240
241	// assertion check
UNCOV 242	await assertAddressOwnership(models, address);	×
243
244	if (req.user) {	×
245	// if user was already logged in, we're done
246	return res.json({
247	status: 'Success',
248	result: { address, message: 'Verified signature' },
249	});	×
250	} else {
251	// if user isn't logged in, log them in now
252	const newAddress = await models.Address.findOne({
253	where: { community_id: req.body.community_id, address },
254	});
255	const user = await models.User.scope('withPrivateData').findOne({
256	// @ts-expect-error StrictNullChecks
257	where: { id: newAddress.user_id },
258	});
259	// @ts-expect-error StrictNullChecks
260	req.login(user, (err) => {
261	const serverAnalyticsController = new ServerAnalyticsController();
262	if (err) {	×
263	serverAnalyticsController.track(
264	{
265	event: MixpanelLoginEvent.LOGIN_FAILED,
266	},
267	req,
268	);
269	return next(err);
270	}
271	serverAnalyticsController.track(
272	{
273	event: MixpanelLoginEvent.LOGIN_COMPLETED,
274	// @ts-expect-error StrictNullChecks
275	userId: user.id,
276	},
277	req,
278	);
279
280	return res.json({
281	status: 'Success',
282	result: {
283	user,
284	address,
285	message: 'Signed in',
286	},
287	});
288	});
289	}
290	};
291
292	export default verifyAddress;

hicommonwealth / commonwealth / 9551722483

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