refactor(networks): expose canonical network symbols

Author: peter-sanderson

networks/bitcoin/network-bitcoin-suite-common/src/addressValidator/bitcoinAddressValidator.test.ts

@@ -5,13 +5,20 @@ import { keccak_256 } from '@noble/hashes/sha3.js';
 import { bytesToHex, hexToBytes } from '@noble/hashes/utils.js';
 import { base58 } from '@scure/base';
 
-import { asNetworkSymbol } from '@trezor/network-module';
 import { type AddressValidator, addressType } from '@trezor/network-module-suite-common-types';
 import { typedObjectKeys } from '@trezor/utils';
 
 import { bchValidator } from './bchAddressValidator';
 import * as bech32 from './bech32';
-import type { BitcoinNetworkSymbol } from '../supportedNetworks';
+import {
+    type BitcoinNetworkSymbol,
+    btcSymbol,
+    dogeSymbol,
+    ltcSymbol,
+    regtestSymbol,
+    testSymbol,
+    zecSymbol,
+} from '../supportedNetworks';
 
 type NetworkEnvironment = 'prod' | 'testnet' | 'regtest' | 'stake';
 type HashFunction = 'sha256' | 'blake256' | 'blake256keccak256' | 'keccak256';
@@ -37,28 +44,28 @@ const BITCOIN_NETWORK_CONFIG = {
 
 const BITCOIN_CURRENCIES: Record<BitcoinCurrencySymbol, BitcoinCurrency> = {
     btc: {
-        symbol: asNetworkSymbol('btc'),
+        symbol: btcSymbol,
         ...BITCOIN_NETWORK_CONFIG,
     },
     test: {
-        symbol: asNetworkSymbol('test'),
+        symbol: testSymbol,
         ...BITCOIN_NETWORK_CONFIG,
     },
     regtest: {
-        symbol: asNetworkSymbol('regtest'),
+        symbol: regtestSymbol,
         ...BITCOIN_NETWORK_CONFIG,
     },
     ltc: {
-        symbol: asNetworkSymbol('ltc'),
+        symbol: ltcSymbol,
         segwitHrp: { prod: 'ltc', testnet: 'tltc' },
         addressTypes: { prod: ['30', '32'], testnet: ['6f', 'c4', '3a'] },
     },
     doge: {
-        symbol: asNetworkSymbol('doge'),
+        symbol: dogeSymbol,
         addressTypes: { prod: ['1e', '16'], testnet: ['71', 'c4'] },
     },
     zec: {
-        symbol: asNetworkSymbol('zec'),
+        symbol: zecSymbol,
         expectedLength: 26,
         addressTypes: { prod: ['1cb8', '1cbd'], testnet: ['1d25', '1cba'] },
     },

networks/bitcoin/network-bitcoin-suite-common/src/addressValidator/bitcoinAddressValidator.ts

@@ -1 +1,11 @@
 export { createBitcoinSuiteCommonNetworkModule } from './BitcoinNetworkSuiteCommonNetworkModule';
+export {
+    bchSymbol,
+    btcSymbol,
+    dogeSymbol,
+    ltcSymbol,
+    regtestSymbol,
+    testSymbol,
+    zecSymbol,
+    type BitcoinNetworkSymbol,
+} from './supportedNetworks';

networks/bitcoin/network-bitcoin-suite-common/src/index.ts

@@ -1,13 +1,21 @@
 import { type NetworkSymbol, asNetworkSymbol } from '@trezor/network-module';
 
+export const btcSymbol = asNetworkSymbol('btc');
+export const testSymbol = asNetworkSymbol('test');
+export const regtestSymbol = asNetworkSymbol('regtest');
+export const ltcSymbol = asNetworkSymbol('ltc');
+export const dogeSymbol = asNetworkSymbol('doge');
+export const zecSymbol = asNetworkSymbol('zec');
+export const bchSymbol = asNetworkSymbol('bch');
+
 export const supportedNetworks = [
-    asNetworkSymbol('btc'),
-    asNetworkSymbol('test'),
-    asNetworkSymbol('regtest'),
-    asNetworkSymbol('ltc'),
-    asNetworkSymbol('doge'),
-    asNetworkSymbol('zec'),
-    asNetworkSymbol('bch'),
+    btcSymbol,
+    testSymbol,
+    regtestSymbol,
+    ltcSymbol,
+    dogeSymbol,
+    zecSymbol,
+    bchSymbol,
 ] as const;
 
 export type BitcoinNetworkSymbol = (typeof supportedNetworks)[number];

networks/bitcoin/network-bitcoin-suite-common/src/supportedNetworks.ts

@@ -1,19 +1,19 @@
-import { asNetworkSymbol } from '@trezor/network-module';
 import { type AddressType, addressType } from '@trezor/network-module-suite-common-types';
 
+import { adaSymbol } from '../supportedNetworks';
 import { adaValidator } from './cardanoAddressValidator';
 
 type CardanoIsAddressValidCase = {
-    address: string;
-    expected: boolean;
+    readonly address: string;
+    readonly expected: boolean;
 };
 
 type CardanoAddressTypeCase = {
-    address: string;
-    expectedAddressType: AddressType | undefined;
+    readonly address: string;
+    readonly expectedAddressType: AddressType | undefined;
 };
 
-const cardanoIsAddressValidCases: CardanoIsAddressValidCase[] = [
+const cardanoIsAddressValidCases: readonly CardanoIsAddressValidCase[] = [
     {
         address: 'Ae2tdPwUPEYxYNJw1He1esdZYvjmr4NtPzUsGTiqL9zd8ohjZYQcwu6kom7',
         expected: true,
@@ -118,7 +118,7 @@ const cardanoIsAddressValidCases: CardanoIsAddressValidCase[] = [
     },
 ];
 
-const cardanoAddressTypeCases: CardanoAddressTypeCase[] = [
+const cardanoAddressTypeCases: readonly CardanoAddressTypeCase[] = [
     {
         address: 'Ae2tdPwUPEYxYNJw1He1esdZYvjmr4NtPzUsGTiqL9zd8ohjZYQcwu6kom7',
         expectedAddressType: addressType.ADDRESS,
@@ -138,14 +138,12 @@ describe('cardano validator', () => {
     it.each(cardanoIsAddressValidCases)('validates address $address', testCase => {
         const { address, expected } = testCase;
 
-        expect(adaValidator.isAddressValid(address, asNetworkSymbol('ada'))).toBe(expected);
+        expect(adaValidator.isAddressValid(address, adaSymbol)).toBe(expected);
     });
 
     it.each(cardanoAddressTypeCases)('resolves address type for $address', testCase => {
         const { address, expectedAddressType } = testCase;
 
-        expect(adaValidator.getAddressType(address, asNetworkSymbol('ada'))).toBe(
-            expectedAddressType,
-        );
+        expect(adaValidator.getAddressType(address, adaSymbol)).toBe(expectedAddressType);
     });
 });

networks/cardano/network-cardano-suite-common/src/addressValidator/cardanoAddressValidator.test.ts

@@ -1 +1,2 @@
 export { createCardanoSuiteCommonNetworkModule } from './CardanoNetworkSuiteCommonNetworkModule';
+export { adaSymbol, type CardanoNetworkSymbol } from './supportedNetworks';

networks/cardano/network-cardano-suite-common/src/index.ts

@@ -1,6 +1,8 @@
 import { type NetworkSymbol, asNetworkSymbol } from '@trezor/network-module';
 
-export const supportedNetworks = [asNetworkSymbol('ada')] as const;
+export const adaSymbol = asNetworkSymbol('ada');
+
+export const supportedNetworks = [adaSymbol] as const;
 
 export type CardanoNetworkSymbol = (typeof supportedNetworks)[number];