10816997994

Committed 11 Sep 2024 05:55PM UTC coverage: 13.916% (-0.2%) from 14.158%

Build # 10816997994

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9166 from hicommonwealth/rotorsoft/9051-update-community

Refactors update community

Run Details

2987 of 20092 branches covered (14.87%)

Branch coverage included in aggregate %.

39 of 82 new or added lines in 13 files covered. (47.56%)

3 existing lines in 3 files now uncovered.

3968 of 29885 relevant lines covered (13.28%)

3.94 hits per line

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

26.92

/packages/commonwealth/shared/utils.ts

import { Dec, IntPretty } from '@keplr-wallet/unit';
import { isHex, isU8a } from '@polkadot/util';
import {
  checkAddress,
  decodeAddress,
  encodeAddress,
} from '@polkadot/util-crypto';

export const slugifyPreserveDashes = (str: string): string => {
  // Remove any character that isn't a alphanumeric character, a
  // space, or a dash, and then replace any sequence of spaces with a single dash.

  // return str
  //   .toLowerCase()
  //   .trim()
  //   .replace(/[^A-Za-z0-9]+/g, '-');

  return str
    .replace(/[^A-Za-z0-9 -]/g, '')
    .replace(/(\s|-)+/g, '-')
    .replace(/^-|-$/g, '')
    .toLowerCase();
};

// WARN: Using process.env to avoid webpack failures
export const getCommunityUrl = (community: string): string => {
  return process.env.NODE_ENV === 'production'
    ? `https://commonwealth.im/${community}`
    : `http://localhost:8080/${community}`;
};

export const smartTrim = (text, maxLength = 200) => {
  if (text.length > maxLength) {
    const smartTrimmedText = text.slice(0, maxLength).replace(/\W+$/, '');
    if (smartTrimmedText.length === 0) return `${text.slice(0, maxLength)}...`;
    return `${smartTrimmedText}...`;
  } else {
    return text;
  }
};

export const validURL = (str) => {
  const pattern = new RegExp(
    '^(https?:\\/\\/)?' + // protocol
      '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.)+[a-z]{2,}|' + // domain name
      '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
      '(\\:\\d+)?(\\/[-a-z\\d%_.~+:@]*)*' + // port and path
      '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
      '(\\#[-a-z\\d_]*)?$',
    'i',
  ); // fragment locator
  return !!pattern.test(str);
};

export const urlHasValidHTTPPrefix = (url: string) => {
  return url.indexOf('http://') === 0 || url.indexOf('https://') === 0;
};

export function formatAddressShort(
  address: string,
  chain?: string,
  includeEllipsis?: boolean,
  maxCharLength?: number,
  prefix?: string,
) {
  if (!address) return;
  if (chain === 'near') {
    return `@${address}`;
  } else if (prefix && !maxCharLength) {
    if (!includeEllipsis) return address;
    const totalLength = address.length;
    return `${address.slice(0, prefix.length + 3)}...${address.slice(
      totalLength - 4,
      totalLength,
    )}`;
  } else {
    return `${address.slice(0, maxCharLength || 5)}${
      includeEllipsis ? '…' : ''
    }`;
  }
}

export const addressSwapper = (options: {
  address: string;
  currentPrefix: number;
}): string => {
  if (!options.address) throw new Error('No address provided to swap');

  if (!options.currentPrefix) return options.address;

  if (isU8a(options.address) || isHex(options.address)) {
    throw new Error('address not in SS58 format');
  }

  // check if it is valid as an address
  let decodedAddress: Uint8Array;

  try {
    decodedAddress = decodeAddress(options.address);
  } catch (e) {
    throw new Error('failed to decode address');
  }

  // check if it is valid with the current prefix & reencode if needed
  const [valid] = checkAddress(options.address, options.currentPrefix);

  if (!valid) {
    try {
      return encodeAddress(decodedAddress, options.currentPrefix);
    } catch (e) {
      throw new Error('failed to reencode address');
    }
  } else {
    return options.address;
  }
};

/**
 * Convert Cosmos-style minimal denom amount to readable full-denom amount
 * Example 7000000 uosmo -> 7 OSMO
 * Example 8000000000000000000 aevmos -> 8 EVMOS
 */
export function minimalToNaturalDenom(
  amount?: string | number,
  decimals?: number,
): string {
  if (!amount || !decimals) return '0';
  const intPretty = new IntPretty(
    new Dec(amount.toString()),
  ).moveDecimalPointLeft(decimals);

  // return full decimal precision and let the UI handle rounding
  return intPretty.toDec().toString(decimals);
}

/**
 * Convert readable full-denom amount to minimal denom amount (BigInt)
 * Example 8 OSMO -> 8000000 uosmo
 * Example 8 EVMOS -> 8000000000000000000 aevmos
 * Intended for Cosmos use (decimals usually 6 or 18)
 */
export function naturalDenomToMinimal(
  naturalAmount?: string | number,
  decimals?: number,
): string {
  if (!naturalAmount || !decimals) return '0';
  const intPretty = new IntPretty(
    new Dec(naturalAmount.toString()),
  ).moveDecimalPointRight(decimals);

  // 0 decimal places because this is max precision for the chain
  return intPretty.toDec().toString(0);
}

/**
 * Convert Cosmos bech32 address to a hexadecimal string
 * hex is used as a common identifier for addresses across chains.
 * This allows us to achieve One Signer, One Account
 *
 * Example:
 * bech32ToHex('osmo18q3tlnx8vguv2fadqslm7x59ejauvsmnhltgq6') => '3822bfccc76238c527ad043fbf1a85ccbbc64373'
 * bech32ToHex('cosmos18q3tlnx8vguv2fadqslm7x59ejauvsmnlycckg') => '3822bfccc76238c527ad043fbf1a85ccbbc64373' (same)
 *
 * Caveat: Ethermint addresses will share a hex, but it will differ from
 * their siblings on standard Cosmos derivation paths.
 * e.g. evmos hex != osmo hex, but evmos hex == inj hex
 */
export async function bech32ToHex(address: string) {
  const { toHex, fromBech32 } = await import('@cosmjs/encoding');
  try {
    const encodedData = fromBech32(address).data;
    return toHex(encodedData);
  } catch (e) {
    console.log(`Error converting bech32 to hex: ${e}. Hex was not generated.`);
  }
}

1	import { Dec, IntPretty } from '@keplr-wallet/unit';
2	import { isHex, isU8a } from '@polkadot/util';
3	import {
4	checkAddress,
5	decodeAddress,
6	encodeAddress,
7	} from '@polkadot/util-crypto';
8
9	export const slugifyPreserveDashes = (str: string): string => {	22✔
10	// Remove any character that isn't a alphanumeric character, a
11	// space, or a dash, and then replace any sequence of spaces with a single dash.
12
13	// return str
14	// .toLowerCase()
15	// .trim()
16	// .replace(/[^A-Za-z0-9]+/g, '-');
17
18	return str	×
19	.replace(/[^A-Za-z0-9 -]/g, '')
20	.replace(/(\s\|-)+/g, '-')
21	.replace(/^-\|-$/g, '')
22	.toLowerCase();
23	};
24
25	// WARN: Using process.env to avoid webpack failures
26	export const getCommunityUrl = (community: string): string => {	22✔
27	return process.env.NODE_ENV === 'production'	3!
28	? `https://commonwealth.im/${community}`
29	: `http://localhost:8080/${community}`;
30	};
31
32	export const smartTrim = (text, maxLength = 200) => {	22!
33	if (text.length > maxLength) {	×
34	const smartTrimmedText = text.slice(0, maxLength).replace(/\W+$/, '');	×
35	if (smartTrimmedText.length === 0) return `${text.slice(0, maxLength)}...`;	×
36	return `${smartTrimmedText}...`;	×
37	} else {
38	return text;	×
39	}
40	};
41
42	export const validURL = (str) => {	22✔
43	const pattern = new RegExp(	×
44	'^(https?:\\/\\/)?' + // protocol
45	'((([a-z\\d]([a-z\\d-][a-z\\d]))\\.)+[a-z]{2,}\|' + // domain name
46	'((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
47	'(\\:\\d+)?(\\/[-a-z\\d%_.~+:@])' + // port and path
48	'(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
49	'(\\#[-a-z\\d_]*)?$',
50	'i',
51	); // fragment locator
52	return !!pattern.test(str);	×
53	};
54
55	export const urlHasValidHTTPPrefix = (url: string) => {	22✔
UNCOV 56	return url.indexOf('http://') === 0 \|\| url.indexOf('https://') === 0;	×
57	};
58
59	export function formatAddressShort(
60	address: string,
61	chain?: string,
62	includeEllipsis?: boolean,
63	maxCharLength?: number,
64	prefix?: string,
65	) {
66	if (!address) return;	×
67	if (chain === 'near') {	×
68	return `@${address}`;	×
69	} else if (prefix && !maxCharLength) {	×
70	if (!includeEllipsis) return address;	×
71	const totalLength = address.length;	×
72	return `${address.slice(0, prefix.length + 3)}...${address.slice(	×
73	totalLength - 4,
74	totalLength,
75	)}`;
76	} else {
77	return `${address.slice(0, maxCharLength \|\| 5)}${	×
78	includeEllipsis ? '…' : ''	×
79	}`;
80	}
81	}
82
83	export const addressSwapper = (options: {	22✔
84	address: string;
85	currentPrefix: number;
86	}): string => {
87	if (!options.address) throw new Error('No address provided to swap');	×
88
89	if (!options.currentPrefix) return options.address;	×
90
91	if (isU8a(options.address) \|\| isHex(options.address)) {	×
92	throw new Error('address not in SS58 format');	×
93	}
94
95	// check if it is valid as an address
96	let decodedAddress: Uint8Array;
97
98	try {	×
99	decodedAddress = decodeAddress(options.address);	×
100	} catch (e) {
101	throw new Error('failed to decode address');	×
102	}
103
104	// check if it is valid with the current prefix & reencode if needed
105	const [valid] = checkAddress(options.address, options.currentPrefix);	×
106
107	if (!valid) {	×
108	try {	×
109	return encodeAddress(decodedAddress, options.currentPrefix);	×
110	} catch (e) {
111	throw new Error('failed to reencode address');	×
112	}
113	} else {
114	return options.address;	×
115	}
116	};
117
118	/**
119	* Convert Cosmos-style minimal denom amount to readable full-denom amount
120	* Example 7000000 uosmo -> 7 OSMO
121	* Example 8000000000000000000 aevmos -> 8 EVMOS
122	*/
123	export function minimalToNaturalDenom(
124	amount?: string \| number,
125	decimals?: number,
126	): string {
127	if (!amount \|\| !decimals) return '0';	21✔
128	const intPretty = new IntPretty(	17✔
129	new Dec(amount.toString()),
130	).moveDecimalPointLeft(decimals);
131
132	// return full decimal precision and let the UI handle rounding
133	return intPretty.toDec().toString(decimals);	17✔
134	}
135
136	/**
137	* Convert readable full-denom amount to minimal denom amount (BigInt)
138	* Example 8 OSMO -> 8000000 uosmo
139	* Example 8 EVMOS -> 8000000000000000000 aevmos
140	* Intended for Cosmos use (decimals usually 6 or 18)
141	*/
142	export function naturalDenomToMinimal(
143	naturalAmount?: string \| number,
144	decimals?: number,
145	): string {
146	if (!naturalAmount \|\| !decimals) return '0';	20✔
147	const intPretty = new IntPretty(	16✔
148	new Dec(naturalAmount.toString()),
149	).moveDecimalPointRight(decimals);
150
151	// 0 decimal places because this is max precision for the chain
152	return intPretty.toDec().toString(0);	16✔
153	}
154
155	/**
156	* Convert Cosmos bech32 address to a hexadecimal string
157	* hex is used as a common identifier for addresses across chains.
158	* This allows us to achieve One Signer, One Account
159	*
160	* Example:
161	* bech32ToHex('osmo18q3tlnx8vguv2fadqslm7x59ejauvsmnhltgq6') => '3822bfccc76238c527ad043fbf1a85ccbbc64373'
162	* bech32ToHex('cosmos18q3tlnx8vguv2fadqslm7x59ejauvsmnlycckg') => '3822bfccc76238c527ad043fbf1a85ccbbc64373' (same)
163	*
164	* Caveat: Ethermint addresses will share a hex, but it will differ from
165	* their siblings on standard Cosmos derivation paths.
166	* e.g. evmos hex != osmo hex, but evmos hex == inj hex
167	*/
168	export async function bech32ToHex(address: string) {
169	const { toHex, fromBech32 } = await import('@cosmjs/encoding');	8✔
170	try {	8✔
171	const encodedData = fromBech32(address).data;	8✔
172	return toHex(encodedData);	8✔
173	} catch (e) {
174	console.log(`Error converting bech32 to hex: ${e}. Hex was not generated.`);	×
175	}
176	}

hicommonwealth / commonwealth / 10816997994

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