19151223489

Committed 06 Nov 2025 10:04PM UTC coverage: 37.739% (+0.003%) from 37.736%

Build # 19151223489

Build Type

push

github

Committed by

web-flow

Commit Message

fix model upserts (#13185)

Run Details

2063 of 5854 branches covered (35.24%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

3571 of 9075 relevant lines covered (39.35%)

45.43 hits per line

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

0.0

/libs/model/src/aggregates/token/ProjectLaunchpadTrade.command.ts

import { Command } from '@hicommonwealth/core';
import * as schemas from '@hicommonwealth/schemas';
import { UserTierMap } from '@hicommonwealth/shared';
import { Op } from 'sequelize';
import { z } from 'zod';
import { models } from '../../database';
import { chainNodeMustExist } from '../../policies/utils/utils';
import { setUserTier } from '../../utils/tiers';
import { handleCapReached } from './utils';

export function ProjectLaunchpadTrade(): Command<
  typeof schemas.ProjectLaunchpadTrade
> {
  return {
    ...schemas.ProjectLaunchpadTrade,
    auth: [],
    body: async ({ payload }) => {
      const {
        block_timestamp,
        transaction_hash,
        token_address: token_address_unformatted,
        trader_address,
        is_buy,
        eth_chain_id,
        eth_amount,
        community_token_amount,
        floating_supply,
      } = payload;

      const output: z.infer<(typeof schemas.ProjectLaunchpadTrade)['output']> =
        {};
      const token_address = token_address_unformatted.toLowerCase();
      const chainNode = await chainNodeMustExist(eth_chain_id);

      const token = await models.LaunchpadToken.findOne({
        where: { token_address },
        attributes: ['namespace'],
      });
      if (!token) return output; // ignore if token not found

      const community = await models.Community.findOne({
        where: { namespace: token.namespace },
        attributes: ['id'],
      });
      const user_addr = await models.Address.scope('withPrivateData').findOne({
        where: {
          address: trader_address,
          user_id: { [Op.not]: null },
        },
        attributes: [
          'user_id',
          'role',
          'ghost_address',
          'is_banned',
          'verification_token',
        ],
      });

      await models.sequelize.transaction(async (transaction) => {
        await models.LaunchpadTrade.findOrCreate({
          where: { eth_chain_id, transaction_hash },
          defaults: {
            eth_chain_id,
            transaction_hash,
            token_address,
            trader_address,
            is_buy,
            community_token_amount,
            price:
              Number((eth_amount * BigInt(1e18)) / community_token_amount) /
              1e18,
            floating_supply,
            timestamp: Number(block_timestamp),
          },
          transaction,
        });

        // auto-join community after trades
        if (community && user_addr) {
          output.community_id = community.id;
          await models.Address.findOrCreate({
            where: {
              community_id: community.id,
              address: trader_address,
            },
            defaults: {
              community_id: community.id,
              address: trader_address,
              user_id: user_addr.user_id,
              role: user_addr.role ?? 'member',
              ghost_address: user_addr.ghost_address ?? false,
              is_banned: user_addr.is_banned ?? false,
              verification_token: user_addr.verification_token,
            },
            transaction,
          });
        }

        await setUserTier({
          userAddress: trader_address,
          newTier: UserTierMap.ChainVerified,
          transaction,
        });
      });

      // If cap reached, transfer to uniswap
      // TODO: what happens if something goes wrong here? Should this be a policy with a retry?
      await handleCapReached(
        token_address,
        floating_supply,
        trader_address,
        eth_chain_id,
        chainNode.private_url!,
        is_buy,
      );

      return output;
    },
  };
}

1	import { Command } from '@hicommonwealth/core';
2	import * as schemas from '@hicommonwealth/schemas';
3	import { UserTierMap } from '@hicommonwealth/shared';
4	import { Op } from 'sequelize';
5	import { z } from 'zod';
6	import { models } from '../../database';
7	import { chainNodeMustExist } from '../../policies/utils/utils';
8	import { setUserTier } from '../../utils/tiers';
9	import { handleCapReached } from './utils';
10
11	export function ProjectLaunchpadTrade(): Command<
12	typeof schemas.ProjectLaunchpadTrade
13	> {
14	return {	×
15	...schemas.ProjectLaunchpadTrade,
16	auth: [],
17	body: async ({ payload }) => {
18	const {
19	block_timestamp,
20	transaction_hash,
21	token_address: token_address_unformatted,
22	trader_address,
23	is_buy,
24	eth_chain_id,
25	eth_amount,
26	community_token_amount,
27	floating_supply,
28	} = payload;	×
29
30	const output: z.infer<(typeof schemas.ProjectLaunchpadTrade)['output']> =
31	{};	×
UNCOV 32	const token_address = token_address_unformatted.toLowerCase();	×
33	const chainNode = await chainNodeMustExist(eth_chain_id);	×
34
NEW 35	const token = await models.LaunchpadToken.findOne({	×
36	where: { token_address },
37	attributes: ['namespace'],
38	});
NEW 39	if (!token) return output; // ignore if token not found	×
40
NEW 41	const community = await models.Community.findOne({	×
42	where: { namespace: token.namespace },
43	attributes: ['id'],
44	});
NEW 45	const user_addr = await models.Address.scope('withPrivateData').findOne({	×
46	where: {
47	address: trader_address,
48	user_id: { [Op.not]: null },
49	},
50	attributes: [
51	'user_id',
52	'role',
53	'ghost_address',
54	'is_banned',
55	'verification_token',
56	],
57	});
58
59	await models.sequelize.transaction(async (transaction) => {	×
60	await models.LaunchpadTrade.findOrCreate({	×
61	where: { eth_chain_id, transaction_hash },
62	defaults: {
63	eth_chain_id,
64	transaction_hash,
65	token_address,
66	trader_address,
67	is_buy,
68	community_token_amount,
69	price:
70	Number((eth_amount * BigInt(1e18)) / community_token_amount) /
71	1e18,
72	floating_supply,
73	timestamp: Number(block_timestamp),
74	},
75	transaction,
76	});
77
78	// auto-join community after trades
NEW 79	if (community && user_addr) {	×
NEW 80	output.community_id = community.id;	×
NEW 81	await models.Address.findOrCreate({	×
82	where: {
83	community_id: community.id,
84	address: trader_address,
85	},
86	defaults: {
87	community_id: community.id,
88	address: trader_address,
89	user_id: user_addr.user_id,
90	role: user_addr.role ?? 'member',	×
91	ghost_address: user_addr.ghost_address ?? false,	×
92	is_banned: user_addr.is_banned ?? false,	×
93	verification_token: user_addr.verification_token,
94	},
95	transaction,
96	});
97	}
98
UNCOV 99	await setUserTier({	×
100	userAddress: trader_address,
101	newTier: UserTierMap.ChainVerified,
102	transaction,
103	});
104	});
105
106	// If cap reached, transfer to uniswap
107	// TODO: what happens if something goes wrong here? Should this be a policy with a retry?
108	await handleCapReached(	×
109	token_address,
110	floating_supply,
111	trader_address,
112	eth_chain_id,
113	chainNode.private_url!,
114	is_buy,
115	);
116
117	return output;	×
118	},
119	};
120	}

hicommonwealth / commonwealth / 19151223489

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