14870193493

Committed 06 May 2025 09:35PM UTC coverage: 43.081% (-0.6%) from 43.654%

Build # 14870193493

Build Type

Pull #12056

github

Committed by

web-flow

Commit Message

Merge 7a94be300 into 2bbbdfe0a

Pull Request Pull Request #12056: Judged contest fixes

Coverage Stats

1685 of 4323 branches covered (38.98%)

Branch coverage included in aggregate %.

4 of 16 new or added lines in 4 files covered. (25.0%)

156 existing lines in 14 files now uncovered.

3050 of 6668 relevant lines covered (45.74%)

37.71 hits per line

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

35.4

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

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

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;
          }
        }
      }
    }
  }

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

hicommonwealth / commonwealth / 14870193493

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