16654489606

Committed 31 Jul 2025 04:23PM UTC coverage: 38.356% (-0.8%) from 39.148%

Build # 16654489606

Build Type

Pull #12697

github

Committed by

web-flow

Commit Message

Merge bcbe9f130 into febfac2fb

Pull Request Pull Request #12697: Topic Subscriptions

Run Details

1861 of 5228 branches covered (35.6%)

Branch coverage included in aggregate %.

2 of 13 new or added lines in 7 files covered. (15.38%)

107 existing lines in 6 files now uncovered.

3296 of 8217 relevant lines covered (40.11%)

35.08 hits per line

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

32.54

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

import {
  BalanceSourceType,
  type ContractSource,
  type CosmosContractSource,
  type CosmosSource,
  type NativeSource,
  type SolanaSource,
  type SuiSource,
  type SuiTokenSource,
  type SuiNFTSource,
} from '@hicommonwealth/shared';
import type { GroupAttributes } from '../models/group';
import type {
  GetBalancesOptions,
  GetCosmosBalancesOptions,
  GetCwBalancesOptions,
  GetErc1155BalanceOptions,
  GetErcBalanceOptions,
  GetEthNativeBalanceOptions,
  GetSPLBalancesOptions,
  GetSuiNativeBalanceOptions,
  GetSuiTokenBalanceOptions,
  GetSuiNftBalanceOptions,
} from '../services/tokenBalanceCache/types';

export function makeGetBalancesOptions(
  groups: GroupAttributes[],
  addresses: string[],
): GetBalancesOptions[] {
  const allOptions: GetBalancesOptions[] = [];

  for (const group of groups) {
    for (const requirement of group.requirements) {
      if (requirement.rule === 'threshold') {
        // for each requirement, upsert the appropriate option
        switch (requirement.data.source.source_type) {
          case BalanceSourceType.ERC20:
          case BalanceSourceType.ERC721: {
            const castedSource = requirement.data.source as ContractSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetErcBalanceOptions;
              return (
                castedOpt.balanceSourceType === castedSource.source_type &&
                castedOpt.sourceOptions.evmChainId ===
                  castedSource.evm_chain_id &&
                castedOpt.sourceOptions.contractAddress ===
                  castedSource.contract_address
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: castedSource.source_type as
                  | BalanceSourceType.ERC20
                  | BalanceSourceType.ERC721,
                sourceOptions: {
                  contractAddress: castedSource.contract_address,
                  evmChainId: castedSource.evm_chain_id,
                },
                addresses,
              });
            }
            break;
          }
          case BalanceSourceType.ERC1155: {
            const castedSource = requirement.data.source as ContractSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetErc1155BalanceOptions;
              return (
                castedOpt.balanceSourceType === BalanceSourceType.ERC1155 &&
                castedOpt.sourceOptions.evmChainId ===
                  castedSource.evm_chain_id &&
                castedOpt.sourceOptions.contractAddress ===
                  castedSource.contract_address &&
                castedOpt.sourceOptions.tokenId ===
                  parseInt(castedSource.token_id!, 10)
              );
            });

            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: BalanceSourceType.ERC1155,
                sourceOptions: {
                  evmChainId: castedSource.evm_chain_id,
                  contractAddress: castedSource.contract_address,
                  tokenId: parseInt(castedSource.token_id!, 10),
                },
                addresses,
              });
            }
            break;
          }
          // NativeSource
          case BalanceSourceType.ETHNative: {
            const castedSource = requirement.data.source as NativeSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetEthNativeBalanceOptions;
              return (
                castedOpt.balanceSourceType === BalanceSourceType.ETHNative &&
                castedOpt.sourceOptions.evmChainId === castedSource.evm_chain_id
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: BalanceSourceType.ETHNative,
                sourceOptions: {
                  evmChainId: castedSource.evm_chain_id,
                },
                addresses,
              });
            }
            break;
          }
          // CosmosSource
          case BalanceSourceType.CosmosNative: {
            const castedSource = requirement.data.source as CosmosSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetCosmosBalancesOptions;
              return (
                castedOpt.balanceSourceType ===
                  BalanceSourceType.CosmosNative &&
                castedOpt.sourceOptions.cosmosChainId ===
                  castedSource.cosmos_chain_id
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: BalanceSourceType.CosmosNative,
                sourceOptions: {
                  cosmosChainId: castedSource.cosmos_chain_id,
                },
                addresses,
              });
            }
            break;
          }
          // CosmosContractSource
          case BalanceSourceType.CW20:
          case BalanceSourceType.CW721: {
            const castedSource = requirement.data
              .source as CosmosContractSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetCwBalancesOptions;
              return (
                castedOpt.balanceSourceType === castedSource.source_type &&
                castedOpt.sourceOptions.cosmosChainId ===
                  castedSource.cosmos_chain_id &&
                castedOpt.sourceOptions.contractAddress ===
                  castedSource.contract_address
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: castedSource.source_type,
                sourceOptions: {
                  contractAddress: castedSource.contract_address,
                  cosmosChainId: castedSource.cosmos_chain_id,
                },
                addresses,
              });
            }
            break;
          }
          case BalanceSourceType.SOLNFT:
          case BalanceSourceType.SPL: {
            const castedSource = requirement.data.source as SolanaSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetSPLBalancesOptions;
              return (
                castedOpt.balanceSourceType === castedSource.source_type &&
                castedOpt.mintAddress === castedSource.contract_address
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: castedSource.source_type,
                mintAddress: castedSource.contract_address,
                solanaNetwork: castedSource.solana_network,
                addresses,
              });
            }
            break;
          }
          // SuiSource
          case BalanceSourceType.SuiNative: {
            const castedSource = requirement.data.source as SuiSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetSuiNativeBalanceOptions;
              return (
                castedOpt.balanceSourceType === BalanceSourceType.SuiNative &&
                castedOpt.sourceOptions.suiNetwork ===
                  castedSource.sui_network &&
                castedOpt.sourceOptions.objectId === castedSource.object_id
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: BalanceSourceType.SuiNative,
                sourceOptions: {
                  suiNetwork: castedSource.sui_network,
                  objectId: castedSource.object_id,
                },
                addresses,
              });
            }
            break;
          }
          // SuiTokenSource
          case BalanceSourceType.SuiToken: {
            const castedSource = requirement.data.source as SuiTokenSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetSuiTokenBalanceOptions;
              return (
                castedOpt.balanceSourceType === BalanceSourceType.SuiToken &&
                castedOpt.sourceOptions.suiNetwork ===
                  castedSource.sui_network &&
                castedOpt.sourceOptions.coinType === castedSource.coin_type
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: BalanceSourceType.SuiToken,
                sourceOptions: {
                  suiNetwork: castedSource.sui_network,
                  coinType: castedSource.coin_type,
                },
                addresses,
              });
            }
            break;
          }
          case BalanceSourceType.SuiNFT: {
            const castedSource = requirement.data.source as SuiNFTSource;
            const existingOptions = allOptions.find((opt) => {
              const castedOpt = opt as GetSuiNftBalanceOptions;
              return (
                castedOpt.balanceSourceType === BalanceSourceType.SuiNFT &&
                castedOpt.sourceOptions.suiNetwork ===
                  castedSource.sui_network &&
                castedOpt.sourceOptions.collectionId ===
                  castedSource.collection_id
              );
            });
            if (!existingOptions) {
              allOptions.push({
                balanceSourceType: BalanceSourceType.SuiNFT,
                sourceOptions: {
                  suiNetwork: castedSource.sui_network,
                  collectionId: castedSource.collection_id,
                },
                addresses,
              });
            }
            break;
          }
        }
      }
    }
  }

  return allOptions;
}

1	import {
2	BalanceSourceType,
3	type ContractSource,
4	type CosmosContractSource,
5	type CosmosSource,
6	type NativeSource,
7	type SolanaSource,
8	type SuiSource,
9	type SuiTokenSource,
10	type SuiNFTSource,
11	} from '@hicommonwealth/shared';
12	import type { GroupAttributes } from '../models/group';
13	import type {
14	GetBalancesOptions,
15	GetCosmosBalancesOptions,
16	GetCwBalancesOptions,
17	GetErc1155BalanceOptions,
18	GetErcBalanceOptions,
19	GetEthNativeBalanceOptions,
20	GetSPLBalancesOptions,
21	GetSuiNativeBalanceOptions,
22	GetSuiTokenBalanceOptions,
23	GetSuiNftBalanceOptions,
24	} from '../services/tokenBalanceCache/types';
25
26	export function makeGetBalancesOptions(
27	groups: GroupAttributes[],
28	addresses: string[],
29	): GetBalancesOptions[] {
30	const allOptions: GetBalancesOptions[] = [];	8✔
31
32	for (const group of groups) {	8✔
33	for (const requirement of group.requirements) {	14✔
34	if (requirement.rule === 'threshold') {	21✔
35	// for each requirement, upsert the appropriate option
36	switch (requirement.data.source.source_type) {	11!
37	case BalanceSourceType.ERC20:
38	case BalanceSourceType.ERC721: {
39	const castedSource = requirement.data.source as ContractSource;	5✔
40	const existingOptions = allOptions.find((opt) => {	5✔
41	const castedOpt = opt as GetErcBalanceOptions;	6✔
42	return (	6✔
43	castedOpt.balanceSourceType === castedSource.source_type &&	6!
44	castedOpt.sourceOptions.evmChainId ===
45	castedSource.evm_chain_id &&
46	castedOpt.sourceOptions.contractAddress ===
47	castedSource.contract_address
48	);
49	});
50	if (!existingOptions) {	5!
51	allOptions.push({	5✔
52	balanceSourceType: castedSource.source_type as
53	\| BalanceSourceType.ERC20
54	\| BalanceSourceType.ERC721,
55	sourceOptions: {
56	contractAddress: castedSource.contract_address,
57	evmChainId: castedSource.evm_chain_id,
58	},
59	addresses,
60	});
61	}
62	break;	5✔
63	}
64	case BalanceSourceType.ERC1155: {
65	const castedSource = requirement.data.source as ContractSource;	×
66	const existingOptions = allOptions.find((opt) => {	×
UNCOV 67	const castedOpt = opt as GetErc1155BalanceOptions;	×
UNCOV 68	return (	×
69	castedOpt.balanceSourceType === BalanceSourceType.ERC1155 &&	×
70	castedOpt.sourceOptions.evmChainId ===
71	castedSource.evm_chain_id &&
72	castedOpt.sourceOptions.contractAddress ===
73	castedSource.contract_address &&
74	castedOpt.sourceOptions.tokenId ===
75	parseInt(castedSource.token_id!, 10)
76	);
77	});
78
UNCOV 79	if (!existingOptions) {	×
UNCOV 80	allOptions.push({	×
81	balanceSourceType: BalanceSourceType.ERC1155,
82	sourceOptions: {
83	evmChainId: castedSource.evm_chain_id,
84	contractAddress: castedSource.contract_address,
85	tokenId: parseInt(castedSource.token_id!, 10),
86	},
87	addresses,
88	});
89	}
UNCOV 90	break;	×
91	}
92	// NativeSource
93	case BalanceSourceType.ETHNative: {
94	const castedSource = requirement.data.source as NativeSource;	4✔
95	const existingOptions = allOptions.find((opt) => {	4✔
96	const castedOpt = opt as GetEthNativeBalanceOptions;	5✔
97	return (	5✔
98	castedOpt.balanceSourceType === BalanceSourceType.ETHNative &&	7✔
99	castedOpt.sourceOptions.evmChainId === castedSource.evm_chain_id
100	);
101	});
102	if (!existingOptions) {	4✔
103	allOptions.push({	3✔
104	balanceSourceType: BalanceSourceType.ETHNative,
105	sourceOptions: {
106	evmChainId: castedSource.evm_chain_id,
107	},
108	addresses,
109	});
110	}
111	break;	4✔
112	}
113	// CosmosSource
114	case BalanceSourceType.CosmosNative: {
115	const castedSource = requirement.data.source as CosmosSource;	2✔
116	const existingOptions = allOptions.find((opt) => {	2✔
117	const castedOpt = opt as GetCosmosBalancesOptions;	6✔
118	return (	6✔
119	castedOpt.balanceSourceType ===	6!
120	BalanceSourceType.CosmosNative &&
121	castedOpt.sourceOptions.cosmosChainId ===
122	castedSource.cosmos_chain_id
123	);
124	});
125	if (!existingOptions) {	2!
126	allOptions.push({	2✔
127	balanceSourceType: BalanceSourceType.CosmosNative,
128	sourceOptions: {
129	cosmosChainId: castedSource.cosmos_chain_id,
130	},
131	addresses,
132	});
133	}
134	break;	2✔
135	}
136	// CosmosContractSource
137	case BalanceSourceType.CW20:
138	case BalanceSourceType.CW721: {
139	const castedSource = requirement.data	×
140	.source as CosmosContractSource;
141	const existingOptions = allOptions.find((opt) => {	×
UNCOV 142	const castedOpt = opt as GetCwBalancesOptions;	×
UNCOV 143	return (	×
144	castedOpt.balanceSourceType === castedSource.source_type &&	×
145	castedOpt.sourceOptions.cosmosChainId ===
146	castedSource.cosmos_chain_id &&
147	castedOpt.sourceOptions.contractAddress ===
148	castedSource.contract_address
149	);
150	});
UNCOV 151	if (!existingOptions) {	×
UNCOV 152	allOptions.push({	×
153	balanceSourceType: castedSource.source_type,
154	sourceOptions: {
155	contractAddress: castedSource.contract_address,
156	cosmosChainId: castedSource.cosmos_chain_id,
157	},
158	addresses,
159	});
160	}
UNCOV 161	break;	×
162	}
163	case BalanceSourceType.SOLNFT:
164	case BalanceSourceType.SPL: {
165	const castedSource = requirement.data.source as SolanaSource;	×
166	const existingOptions = allOptions.find((opt) => {	×
UNCOV 167	const castedOpt = opt as GetSPLBalancesOptions;	×
UNCOV 168	return (	×
169	castedOpt.balanceSourceType === castedSource.source_type &&	×
170	castedOpt.mintAddress === castedSource.contract_address
171	);
172	});
UNCOV 173	if (!existingOptions) {	×
UNCOV 174	allOptions.push({	×
175	balanceSourceType: castedSource.source_type,
176	mintAddress: castedSource.contract_address,
177	solanaNetwork: castedSource.solana_network,
178	addresses,
179	});
180	}
UNCOV 181	break;	×
182	}
183	// SuiSource
184	case BalanceSourceType.SuiNative: {
185	const castedSource = requirement.data.source as SuiSource;	×
186	const existingOptions = allOptions.find((opt) => {	×
UNCOV 187	const castedOpt = opt as GetSuiNativeBalanceOptions;	×
UNCOV 188	return (	×
189	castedOpt.balanceSourceType === BalanceSourceType.SuiNative &&	×
190	castedOpt.sourceOptions.suiNetwork ===
191	castedSource.sui_network &&
192	castedOpt.sourceOptions.objectId === castedSource.object_id
193	);
194	});
UNCOV 195	if (!existingOptions) {	×
UNCOV 196	allOptions.push({	×
197	balanceSourceType: BalanceSourceType.SuiNative,
198	sourceOptions: {
199	suiNetwork: castedSource.sui_network,
200	objectId: castedSource.object_id,
201	},
202	addresses,
203	});
204	}
UNCOV 205	break;	×
206	}
207	// SuiTokenSource
208	case BalanceSourceType.SuiToken: {
209	const castedSource = requirement.data.source as SuiTokenSource;	×
210	const existingOptions = allOptions.find((opt) => {	×
UNCOV 211	const castedOpt = opt as GetSuiTokenBalanceOptions;	×
UNCOV 212	return (	×
213	castedOpt.balanceSourceType === BalanceSourceType.SuiToken &&	×
214	castedOpt.sourceOptions.suiNetwork ===
215	castedSource.sui_network &&
216	castedOpt.sourceOptions.coinType === castedSource.coin_type
217	);
218	});
UNCOV 219	if (!existingOptions) {	×
UNCOV 220	allOptions.push({	×
221	balanceSourceType: BalanceSourceType.SuiToken,
222	sourceOptions: {
223	suiNetwork: castedSource.sui_network,
224	coinType: castedSource.coin_type,
225	},
226	addresses,
227	});
228	}
UNCOV 229	break;	×
230	}
231	case BalanceSourceType.SuiNFT: {
UNCOV 232	const castedSource = requirement.data.source as SuiNFTSource;	×
UNCOV 233	const existingOptions = allOptions.find((opt) => {	×
UNCOV 234	const castedOpt = opt as GetSuiNftBalanceOptions;	×
UNCOV 235	return (	×
236	castedOpt.balanceSourceType === BalanceSourceType.SuiNFT &&	×
237	castedOpt.sourceOptions.suiNetwork ===
238	castedSource.sui_network &&
239	castedOpt.sourceOptions.collectionId ===
240	castedSource.collection_id
241	);
242	});
UNCOV 243	if (!existingOptions) {	×
UNCOV 244	allOptions.push({	×
245	balanceSourceType: BalanceSourceType.SuiNFT,
246	sourceOptions: {
247	suiNetwork: castedSource.sui_network,
248	collectionId: castedSource.collection_id,
249	},
250	addresses,
251	});
252	}
UNCOV 253	break;	×
254	}
255	}
256	}
257	}
258	}
259
260	return allOptions;	8✔
261	}

hicommonwealth / commonwealth / 16654489606

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