10773513052

Committed 09 Sep 2024 12:47PM UTC coverage: 14.338% (+0.005%) from 14.333%

Build # 10773513052

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9147 from hicommonwealth/tim/fix-thread-creation

Remove `Addresses.wallet_sso_source`

Run Details

3080 of 19817 branches covered (15.54%)

Branch coverage included in aggregate %.

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

5 existing lines in 3 files now uncovered.

4037 of 29820 relevant lines covered (13.54%)

4.04 hits per line

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

41.38

/packages/commonwealth/server/routes/createAddress.ts

import { AppError } from '@hicommonwealth/core';
import type { AddressAttributes, DB } from '@hicommonwealth/model';
import { AddressInstance } from '@hicommonwealth/model';
import { ChainBase, WalletId, addressSwapper } from '@hicommonwealth/shared';
import { bech32 } from 'bech32';
import crypto from 'crypto';
import { Op } from 'sequelize';
import { MixpanelUserSignupEvent } from '../../shared/analytics/types';
import { bech32ToHex } from '../../shared/utils';
import { config } from '../config';
import { ServerAnalyticsController } from '../controllers/server_analytics_controller';
import type { TypedRequestBody, TypedResponse } from '../types';
import { success } from '../types';

export const Errors = {
  NeedAddress: 'Must provide address',
  NeedCommunity: 'Must provide community',
  NeedWallet: 'Must provide valid walletId',
  InvalidCommunity: 'Invalid community',
  InvalidAddress: 'Invalid address',
};

export type CreateAddressReq = {
  address: string;
  community_id?: string;
  wallet_id: WalletId;
  block_info?: string;
};

type CreateAddressResp = AddressAttributes & {
  newly_created: boolean;
  joined_community: boolean;
};

const createAddress = async (
  models: DB,
  req: TypedRequestBody<CreateAddressReq>,
  res: TypedResponse<CreateAddressResp>,
) => {
  // @ts-expect-error StrictNullChecks
  const user = req.body.user;

  // start the process of creating a new address. this may be called
  // when logged in to link a new address for an existing user, or
  // when logged out to create a new user by showing proof of an address.
  if (!req.body.address) {
    throw new AppError(Errors.NeedAddress);
  }
  if (!req.body.community_id) {
    throw new AppError(Errors.NeedCommunity);
  }
  if (
    !req.body.wallet_id ||
    !Object.values(WalletId).includes(req.body.wallet_id)
  ) {
    throw new AppError(Errors.NeedWallet);
  }
  if (req.body.community_id == 'injective') {
    if (req.body.address.slice(0, 3) !== 'inj')
      throw new AppError('Must join with Injective address');
  } else if (req.body.address.slice(0, 3) === 'inj') {
    throw new AppError('Cannot join with an injective address');
  }

  const serverAnalyticsController = new ServerAnalyticsController();

  const community = await models.Community.findOne({
    where: { id: req.body.community_id },
  });

  if (!community) {
    throw new AppError(Errors.InvalidCommunity);
  }

  // test / convert address as needed
  let encodedAddress = (req.body.address as string).trim();
  let addressHex: string;
  let existingAddressWithHex: AddressInstance;
  try {
    if (community.base === ChainBase.Substrate) {
      encodedAddress = addressSwapper({
        address: req.body.address,
        // @ts-expect-error StrictNullChecks
        currentPrefix: community.ss58_prefix,
      });
    } else if (community.bech32_prefix) {
      // cosmos or injective
      const { words } = bech32.decode(req.body.address, 50);
      encodedAddress = bech32.encode(community.bech32_prefix, words);
      // @ts-expect-error StrictNullChecks
      addressHex = await bech32ToHex(req.body.address);

      // check all addresses for matching hex
      const existingHexes = await models.Address.scope(
        'withPrivateData',
      ).findAll({
        where: { hex: addressHex, verified: { [Op.ne]: null } },
      });
      const existingHexesSorted = existingHexes.sort((a, b) => {
        // sort by latest last_active
        return +b.dataValues.last_active! - +a.dataValues.last_active!;
      });

      // use the latest active address with this hex to assign profile
      existingAddressWithHex = existingHexesSorted?.[0];
    } else if (community.base === ChainBase.Ethereum) {
      const { isAddress } = await import('web3-validator');
      if (!isAddress(encodedAddress)) {
        throw new AppError('Eth address is not valid');
      }
    } else if (community.base === ChainBase.NEAR) {
      throw new AppError('NEAR login not supported');
    } else if (community.base === ChainBase.Solana) {
      const { PublicKey } = await import('@solana/web3.js');
      const key = new PublicKey(encodedAddress);
      if (key.toBase58() !== encodedAddress) {
        throw new AppError(`Solana address is not valid: ${key.toBase58()}`);
      }
    }
  } catch (e) {
    throw new AppError(Errors.InvalidAddress);
  }
  const existingAddress = await models.Address.scope('withPrivateData').findOne(
    {
      where: { community_id: req.body.community_id, address: encodedAddress },
    },
  );

  const addressExistsOnOtherCommunity =
    // @ts-expect-error StrictNullChecks
    !!existingAddressWithHex ||
    (await models.Address.scope('withPrivateData').findOne({
      where: {
        community_id: { [Op.ne]: req.body.community_id },
        address: encodedAddress,
      },
    }));

  if (existingAddress) {
    // address already exists on another user, only take ownership if
    // unverified and expired
    const expiration = existingAddress.verification_token_expires;
    const isExpired = expiration && +expiration <= +new Date();
    const isDisowned = existingAddress.user_id == null;
    const isCurrUser = user && existingAddress.user_id === user.id;
    // if owned by someone else, generate a token but don't replace user until verification
    // if you own it, or if it's unverified, associate with address immediately
    const updatedId =
      user &&
      ((!existingAddress.verified && isExpired) || isDisowned || isCurrUser)
        ? user.id
        : null;

    // Address.updateWithToken
    const verification_token = crypto.randomBytes(18).toString('hex');
    const verification_token_expires = new Date(
      +new Date() + config.AUTH.ADDRESS_TOKEN_EXPIRES_IN * 60 * 1000,
    );
    if (updatedId) {
      existingAddress.user_id = updatedId;
    }
    existingAddress.verification_token = verification_token;
    existingAddress.verification_token_expires = verification_token_expires;
    existingAddress.last_active = new Date();
    existingAddress.block_info = req.body.block_info;

    // @ts-expect-error StrictNullChecks
    existingAddress.hex = addressHex;

    // we update addresses with the wallet used to sign in
    existingAddress.wallet_id = req.body.wallet_id;

    const updatedObj = await existingAddress.save();

    return success(res, {
      ...updatedObj.toJSON(),
      newly_created: false,
      joined_community: false,
    });
  } else {
    // address doesn't exist, add it to the database
    // Address.createWithToken
    const verification_token = crypto.randomBytes(18).toString('hex');
    const verification_token_expires = new Date(
      +new Date() + config.AUTH.ADDRESS_TOKEN_EXPIRES_IN * 60 * 1000,
    );
    const last_active = new Date();
    let user_id = user ? user.id : null;

    // @ts-expect-error StrictNullChecks
    if (existingAddressWithHex) {
      user_id = existingAddressWithHex.user_id;
    }

    const newObj = await models.sequelize.transaction(async (transaction) => {
      return models.Address.create(
        {
          user_id,
          community_id: req.body.community_id!,
          address: encodedAddress,
          hex: addressHex,
          verification_token,
          verification_token_expires,
          block_info: req.body.block_info,
          last_active,
          wallet_id: req.body.wallet_id,
          role: 'member',
          is_user_default: false,
          ghost_address: false,
          is_banned: false,
        },
        { transaction },
      );
    });

    // eslint-disable-next-line @typescript-eslint/no-floating-promises
    serverAnalyticsController.track(
      {
        event: MixpanelUserSignupEvent.NEW_USER_SIGNUP,
        community_id: req.body.community_id,
      },
      req,
    );

    return success(res, {
      ...newObj.toJSON(),
      newly_created: !addressExistsOnOtherCommunity,
      joined_community: !!user,
    });
  }
};

export default createAddress;

1	import { AppError } from '@hicommonwealth/core';
2	import type { AddressAttributes, DB } from '@hicommonwealth/model';
3	import { AddressInstance } from '@hicommonwealth/model';
4	import { ChainBase, WalletId, addressSwapper } from '@hicommonwealth/shared';
5	import { bech32 } from 'bech32';
6	import crypto from 'crypto';
7	import { Op } from 'sequelize';
8	import { MixpanelUserSignupEvent } from '../../shared/analytics/types';
9	import { bech32ToHex } from '../../shared/utils';
10	import { config } from '../config';
11	import { ServerAnalyticsController } from '../controllers/server_analytics_controller';
12	import type { TypedRequestBody, TypedResponse } from '../types';
13	import { success } from '../types';
14
15	export const Errors = {	17✔
16	NeedAddress: 'Must provide address',
17	NeedCommunity: 'Must provide community',
18	NeedWallet: 'Must provide valid walletId',
19	InvalidCommunity: 'Invalid community',
20	InvalidAddress: 'Invalid address',
21	};
22
23	export type CreateAddressReq = {
24	address: string;
25	community_id?: string;
26	wallet_id: WalletId;
27	block_info?: string;
28	};
29
30	type CreateAddressResp = AddressAttributes & {
31	newly_created: boolean;
32	joined_community: boolean;
33	};
34
35	const createAddress = async (	17✔
36	models: DB,
37	req: TypedRequestBody<CreateAddressReq>,
38	res: TypedResponse<CreateAddressResp>,
39	) => {
40	// @ts-expect-error StrictNullChecks
41	const user = req.body.user;	21✔
42
43	// start the process of creating a new address. this may be called
44	// when logged in to link a new address for an existing user, or
45	// when logged out to create a new user by showing proof of an address.
46	if (!req.body.address) {	21!
47	throw new AppError(Errors.NeedAddress);	×
48	}
49	if (!req.body.community_id) {	21!
50	throw new AppError(Errors.NeedCommunity);	×
51	}
52	if (	21!
53	!req.body.wallet_id \|\|	84✔
54	!Object.values(WalletId).includes(req.body.wallet_id)
55	) {
56	throw new AppError(Errors.NeedWallet);	×
57	}
58	if (req.body.community_id == 'injective') {	21!
59	if (req.body.address.slice(0, 3) !== 'inj')	×
60	throw new AppError('Must join with Injective address');	×
61	} else if (req.body.address.slice(0, 3) === 'inj') {	21!
62	throw new AppError('Cannot join with an injective address');	×
63	}
64
65	const serverAnalyticsController = new ServerAnalyticsController();	21✔
66
67	const community = await models.Community.findOne({	21✔
68	where: { id: req.body.community_id },
69	});
70
71	if (!community) {	21!
72	throw new AppError(Errors.InvalidCommunity);	×
73	}
74
75	// test / convert address as needed
76	let encodedAddress = (req.body.address as string).trim();	21✔
77	let addressHex: string;
78	let existingAddressWithHex: AddressInstance;
79	try {	21✔
80	if (community.base === ChainBase.Substrate) {	21!
81	encodedAddress = addressSwapper({	×
82	address: req.body.address,
83	// @ts-expect-error StrictNullChecks
84	currentPrefix: community.ss58_prefix,
85	});
86	} else if (community.bech32_prefix) {	21✔
87	// cosmos or injective
88	const { words } = bech32.decode(req.body.address, 50);	1✔
89	encodedAddress = bech32.encode(community.bech32_prefix, words);	1✔
90	// @ts-expect-error StrictNullChecks
91	addressHex = await bech32ToHex(req.body.address);	1✔
92
93	// check all addresses for matching hex
94	const existingHexes = await models.Address.scope(	1✔
95	'withPrivateData',
96	).findAll({
97	where: { hex: addressHex, verified: { [Op.ne]: null } },
98	});
99	const existingHexesSorted = existingHexes.sort((a, b) => {	1✔
100	// sort by latest last_active
101	return +b.dataValues.last_active! - +a.dataValues.last_active!;	×
102	});
103
104	// use the latest active address with this hex to assign profile
105	existingAddressWithHex = existingHexesSorted?.[0];	1✔
106	} else if (community.base === ChainBase.Ethereum) {	20!
107	const { isAddress } = await import('web3-validator');	20✔
108	if (!isAddress(encodedAddress)) {	20!
109	throw new AppError('Eth address is not valid');	×
110	}
111	} else if (community.base === ChainBase.NEAR) {	×
112	throw new AppError('NEAR login not supported');	×
113	} else if (community.base === ChainBase.Solana) {	×
114	const { PublicKey } = await import('@solana/web3.js');	×
115	const key = new PublicKey(encodedAddress);	×
116	if (key.toBase58() !== encodedAddress) {	×
117	throw new AppError(`Solana address is not valid: ${key.toBase58()}`);	×
118	}
119	}
120	} catch (e) {
121	throw new AppError(Errors.InvalidAddress);	×
122	}
123	const existingAddress = await models.Address.scope('withPrivateData').findOne(	21✔
124	{
125	where: { community_id: req.body.community_id, address: encodedAddress },
126	},
127	);
128
129	const addressExistsOnOtherCommunity =
130	// @ts-expect-error StrictNullChecks
131	!!existingAddressWithHex \|\|	21✔
132	(await models.Address.scope('withPrivateData').findOne({
133	where: {
134	community_id: { [Op.ne]: req.body.community_id },
135	address: encodedAddress,
136	},
137	}));
138
139	if (existingAddress) {	21!
140	// address already exists on another user, only take ownership if
141	// unverified and expired
142	const expiration = existingAddress.verification_token_expires;	×
143	const isExpired = expiration && +expiration <= +new Date();	×
144	const isDisowned = existingAddress.user_id == null;	×
145	const isCurrUser = user && existingAddress.user_id === user.id;	×
146	// if owned by someone else, generate a token but don't replace user until verification
147	// if you own it, or if it's unverified, associate with address immediately
148	const updatedId =
149	user &&	×
150	((!existingAddress.verified && isExpired) \|\| isDisowned \|\| isCurrUser)
151	? user.id
152	: null;
153
154	// Address.updateWithToken
155	const verification_token = crypto.randomBytes(18).toString('hex');	×
156	const verification_token_expires = new Date(	×
157	+new Date() + config.AUTH.ADDRESS_TOKEN_EXPIRES_IN * 60 * 1000,
158	);
159	if (updatedId) {	×
160	existingAddress.user_id = updatedId;	×
161	}
162	existingAddress.verification_token = verification_token;	×
163	existingAddress.verification_token_expires = verification_token_expires;	×
164	existingAddress.last_active = new Date();	×
165	existingAddress.block_info = req.body.block_info;	×
166
167	// @ts-expect-error StrictNullChecks
168	existingAddress.hex = addressHex;	×
169
170	// we update addresses with the wallet used to sign in
171	existingAddress.wallet_id = req.body.wallet_id;	×
172
UNCOV 173	const updatedObj = await existingAddress.save();	×
174
175	return success(res, {	×
176	...updatedObj.toJSON(),
177	newly_created: false,
178	joined_community: false,
179	});
180	} else {
181	// address doesn't exist, add it to the database
182	// Address.createWithToken
183	const verification_token = crypto.randomBytes(18).toString('hex');	21✔
184	const verification_token_expires = new Date(	21✔
185	+new Date() + config.AUTH.ADDRESS_TOKEN_EXPIRES_IN * 60 * 1000,
186	);
187	const last_active = new Date();	21✔
188	let user_id = user ? user.id : null;	21!
189
190	// @ts-expect-error StrictNullChecks
191	if (existingAddressWithHex) {	21!
192	user_id = existingAddressWithHex.user_id;	×
193	}
194
195	const newObj = await models.sequelize.transaction(async (transaction) => {	21✔
196	return models.Address.create(	21✔
197	{
198	user_id,
199	community_id: req.body.community_id!,
200	address: encodedAddress,
201	hex: addressHex,
202	verification_token,
203	verification_token_expires,
204	block_info: req.body.block_info,
205	last_active,
206	wallet_id: req.body.wallet_id,
207	role: 'member',
208	is_user_default: false,
209	ghost_address: false,
210	is_banned: false,
211	},
212	{ transaction },
213	);
214	});
215
216	// eslint-disable-next-line @typescript-eslint/no-floating-promises
217	serverAnalyticsController.track(	21✔
218	{
219	event: MixpanelUserSignupEvent.NEW_USER_SIGNUP,
220	community_id: req.body.community_id,
221	},
222	req,
223	);
224
225	return success(res, {	21✔
226	...newObj.toJSON(),
227	newly_created: !addressExistsOnOtherCommunity,
228	joined_community: !!user,
229	});
230	}
231	};
232
233	export default createAddress;

hicommonwealth / commonwealth / 10773513052

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