improved Address module: refactored address/crossAccountId extraction

Author: fend25

README.md

@@ -48,7 +48,9 @@ import {Utf8, Utf16, HexString} from '@unique-nft/utils/string'
 // import {StringUtils} from '@unique-nft/utils'
 
 Utf8.stringToU8a('a 🌷') // Uint8Array [97, 32, 240, 159, 140, 183]
-Utf8.u8aToString([97, 32, 240, 159, 140, 183]) // "a 🌷"
+Utf8.u8aToString([97, 32, 240, 159, 140, 183]) // "a 🌷" // it takes usual number arrays too
+Utf8.hexStringToString('0x6120f09f8cb7') // "a 🌷"
+Utf8.stringToHexString('a 🌷') // "0x6120f09f8cb7"
 Utf8.lengthInBytes('a 🌷') // 6
 
 Utf16.stringToU16a('a 🌷') // Uint16Array [97, 32, 55356, 57143]

docs/Address.md

@@ -1,56 +1,51 @@
 import {normalizeEthereumAddress} from './ethereum'
 import {normalizeSubstrateAddress} from './substrate'
 import {CrossAccountId} from '../types'
-import {is, mirror, normalize} from './index'
+import {is, mirror, normalize, validate} from './index'
 
-export const guessAddressAndExtractItNormalizedSafe = (address: string | object): string | null => {
-  if (typeof address === 'object') {
-    if (is.substrateAddressObject(address)) return normalize.substrateAddress(address.Substrate)
-    else if (is.substrateAddressObjectUncapitalized(address)) return normalize.substrateAddress(address.substrate)
-    else if (is.ethereumAddressObject(address)) return normalizeEthereumAddress(address.Ethereum)
-    else if (is.ethereumAddressObjectUncapitalized(address)) return normalizeEthereumAddress(address.ethereum)
-    else return null
-  }
-  if (typeof address === 'string') {
-    if (is.substrateAddress(address)) return normalizeSubstrateAddress(address)
-    else if (is.ethereumAddress(address)) return normalizeEthereumAddress(address)
-    else return null
-  }
-
-  return null
-}
+export const guessAddressAndExtractCrossAccountIdUnsafe = (rawAddress: string | object, normalize: boolean = false): CrossAccountId => {
+  const address = rawAddress as any
 
-export const guessAddressAndExtractItNormalized = (address: string | object): string => {
-  const result = guessAddressAndExtractItNormalizedSafe(address)
-  if (!result) {
-    throw new Error(`Passed address is not a valid address string or object: ${JSON.stringify(address).slice(0, 100)}`)
+  if (typeof address === 'object') {
+    if (address.hasOwnProperty('Substrate')) {
+      validate.substrateAddress(address.Substrate)
+      return {Substrate: normalize ? normalizeSubstrateAddress(address.Substrate) : address.Substrate}
+    } else if (address.hasOwnProperty('substrate')) {
+      validate.substrateAddress(address.substrate)
+      return {Substrate: normalize ? normalizeSubstrateAddress(address.substrate) : address.substrate}
+    } else if (address.hasOwnProperty('Ethereum')) {
+      validate.ethereumAddress(address.Ethereum)
+      return {Ethereum: normalize ? normalizeEthereumAddress(address.Ethereum) : address.Ethereum}
+    } else if (address.hasOwnProperty('ethereum')) {
+      validate.ethereumAddress(address.ethereum)
+      return {Ethereum: normalize ? normalizeEthereumAddress(address.ethereum) : address.ethereum}
+    } else {
+      throw new Error(`Address ${address} is not a valid crossAccountId object (should contain "Substrate"/"substrate" or "Ethereum"/"ethereum" field)`)
+    }
   }
-  return result
-}
 
-export const addressToCrossAccountId = (address: string): CrossAccountId => {
-  if (is.substrateAddress(address)) {
-    return {Substrate: address}
-  } else if (is.ethereumAddress(address)) {
-    return {Ethereum: address}
+  if (typeof address === 'string') {
+    if (is.substrateAddress(address)) return {Substrate: normalize ? normalizeSubstrateAddress(address) : address}
+    else if (is.ethereumAddress(address)) return {Ethereum: normalize ? normalizeEthereumAddress(address) : address}
+    else {
+      throw new Error(`Address ${address} is not a valid Substrate or Ethereum address`)
+    }
   }
 
-  throw new Error(`Passed address ${address} is not substrate nor ethereum address`)
+  throw new Error(`Address ${address} is not a string or object: ${typeof address}`)
 }
 
-export const addressToCrossAccountIdNormalized = (address: string): CrossAccountId => {
-  if (is.substrateAddress(address)) {
-    return {Substrate: normalize.substrateAddress(address)}
-  } else if (is.ethereumAddress(address)) {
-    return {Ethereum: normalize.ethereumAddress(address)}
+export const guessAddressAndExtractCrossAccountIdSafe = (address: string | object, normalize: boolean = false): CrossAccountId | null => {
+  try {
+    return guessAddressAndExtractCrossAccountIdUnsafe(address, normalize)
+  } catch {
+    return null
   }
-
-  throw new Error(`Passed address ${address} is not substrate nor ethereum address`)
 }
 
-export const substrateNormalizedWithMirrorIfEthereum = (address: string): string => {
-  const addressObject = addressToCrossAccountId(address)
+export const substrateOrMirrorIfEthereum = (address: string | object, normalize: boolean = false): string => {
+  const addressObject = guessAddressAndExtractCrossAccountIdUnsafe(address, normalize)
   return addressObject.Substrate
-    ? normalizeSubstrateAddress(addressObject.Substrate)
+    ? addressObject.Substrate
     : mirror.ethereumToSubstrate(addressObject.Ethereum as string)
 }

src/Address/crossAccountId.ts

@@ -24,7 +24,7 @@ export const normalizeEthereumAddress = (address: string) => {
 }
 
 type EthAddressObj = { Ethereum: string }
-export const compareEthereumAddresses = (address1: string | EthAddressObj | object, address2: string | EthAddressObj | object): boolean => {
+export const compareEthereumAddresses = (address1: string | object, address2: string | object): boolean => {
   const addr1 = typeof address1 === 'string'
     ? address1
     : ((address1 as EthAddressObj).Ethereum || (address1 as any).ethereum) as string | undefined

src/Address/ethereum.ts

@@ -20,23 +20,24 @@ import {
   SubAddressObj, SubAddressObjUncapitalized,
 } from '../types'
 import {
-  substrateNormalizedWithMirrorIfEthereum,
-  addressToCrossAccountId, addressToCrossAccountIdNormalized,
-  guessAddressAndExtractItNormalized,
-  guessAddressAndExtractItNormalizedSafe
+  guessAddressAndExtractCrossAccountIdSafe,
+  guessAddressAndExtractCrossAccountIdUnsafe,
+  substrateOrMirrorIfEthereum
 } from './crossAccountId'
 
 import * as algorithms from './imports'
 import * as constants from './constants'
+import {add} from "@noble/hashes/_u64";
 
 export {constants, algorithms}
 
 const ETH_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/
 
 export type DecodeSubstrateAddressResult = {
-  u8a: Uint8Array,
-  hex: string,
+  u8a: Uint8Array
+  hex: string
   bigint: bigint
+  ss58Prefix: number
 }
 
 export const validate = {
@@ -131,20 +132,62 @@ export const nesting = {
   idsToAddress: collectionIdAndTokenIdToNestingAddress,
   addressToIds: nestingAddressToCollectionIdAndTokenId,
 }
-export const to = {
-  crossAccountId: addressToCrossAccountId,
-  crossAccountIdNormalized: addressToCrossAccountIdNormalized,
-  substrateNormalizedOrMirrorIfEthereum: substrateNormalizedWithMirrorIfEthereum,
-}
 
 export const extract = {
-  normalizedAddressFromObject: guessAddressAndExtractItNormalized,
-  normalizedAddressFromObjectSafe: guessAddressAndExtractItNormalizedSafe,
-  crossAccountIdFromObject: (obj: any): CrossAccountId => {
-    return addressToCrossAccountId(guessAddressAndExtractItNormalized(obj))
+  address: (addressOrCrossAccountId: string | object): string => {
+    const crossAccountId = guessAddressAndExtractCrossAccountIdUnsafe(addressOrCrossAccountId)
+    return (crossAccountId.Substrate || crossAccountId.Ethereum) as string
+  },
+  addressSafe: (addressOrCrossAccountId: string | object): string | null => {
+    const crossAccountId = guessAddressAndExtractCrossAccountIdSafe(addressOrCrossAccountId)
+    return crossAccountId ? (crossAccountId.Substrate || crossAccountId.Ethereum) as string : null
+  },
+
+  addressNormalized: (addressOrCrossAccountId: string | object): string => {
+    const crossAccountId = guessAddressAndExtractCrossAccountIdUnsafe(addressOrCrossAccountId, true)
+    return (crossAccountId.Substrate || crossAccountId.Ethereum) as string
+  },
+  addressNormalizedSafe: (addressOrCrossAccountId: string | object): string | null => {
+    const crossAccountId = guessAddressAndExtractCrossAccountIdSafe(addressOrCrossAccountId, true)
+    return crossAccountId ? (crossAccountId.Substrate || crossAccountId.Ethereum) as string : null
+  },
+
+
+  crossAccountId: (addressOrCrossAccountId: string | object): CrossAccountId => {
+    return guessAddressAndExtractCrossAccountIdUnsafe(addressOrCrossAccountId)
+  },
+  crossAccountIdSafe: (addressOrCrossAccountId: string | object): CrossAccountId | null => {
+    return guessAddressAndExtractCrossAccountIdSafe(addressOrCrossAccountId)
+  },
+
+  crossAccountIdNormalized: (addressOrCrossAccountId: string | object): CrossAccountId => {
+    return guessAddressAndExtractCrossAccountIdUnsafe(addressOrCrossAccountId, true)
+  },
+  crossAccountIdNormalizedSafe: (addressOrCrossAccountId: string | object): CrossAccountId | null => {
+    return guessAddressAndExtractCrossAccountIdSafe(addressOrCrossAccountId, true)
   },
-  crossAccountIdFromObjectNormalized: (obj: any): CrossAccountId => {
-    return addressToCrossAccountId(guessAddressAndExtractItNormalized(obj))
+
+
+  substrateOrMirrorIfEthereum: (addressOrCrossAccountId: string | object): string => {
+    return substrateOrMirrorIfEthereum(addressOrCrossAccountId)
+  },
+  substrateOrMirrorIfEthereumSafe: (addressOrCrossAccountId: string | object): string | null => {
+    try {
+      return substrateOrMirrorIfEthereum(addressOrCrossAccountId)
+    } catch {
+      return null
+    }
+  },
+
+  substrateOrMirrorIfEthereumNormalized: (addressOrCrossAccountId: string | object): string => {
+    return substrateOrMirrorIfEthereum(addressOrCrossAccountId, true)
+  },
+  substrateOrMirrorIfEthereumNormalizedSafe: (addressOrCrossAccountId: string | object): string | null => {
+    try {
+      return substrateOrMirrorIfEthereum(addressOrCrossAccountId, true)
+    } catch {
+      return null
+    }
   },
 }
 
@@ -176,7 +219,6 @@ export const Address = {
   validate,
   collection,
   nesting,
-  to,
   extract,
   mirror,
   normalize,

src/Address/index.ts

@@ -33,7 +33,7 @@ const sshash = (data: Uint8Array): Uint8Array => {
   return blake2AsU8a(u8aConcat([SS58_PREFIX, data]), 64);
 }
 
-const checkAddressChecksum = (decoded: Uint8Array): [boolean, number, number, number] => {
+const checkAddressChecksum = (decoded: Uint8Array, ignoreChecksum: boolean = false): [boolean, number, number, number] => {
   const ss58Length = (decoded[0] & 0b0100_0000) ? 2 : 1;
   const ss58Decoded = ss58Length === 1
     ? decoded[0]
@@ -43,13 +43,17 @@ const checkAddressChecksum = (decoded: Uint8Array): [boolean, number, number, nu
   const isPublicKey = [34 + ss58Length, 35 + ss58Length].includes(decoded.length);
   const length = decoded.length - (isPublicKey ? 2 : 1);
 
-  // calculate the hash and do the checksum byte checks
-  const hash = sshash(decoded.subarray(0, length));
-  const isValid = (decoded[0] & 0x80) === 0 && ![46, 47].includes(decoded[0]) && (
-    isPublicKey
-      ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
-      : decoded[decoded.length - 1] === hash[0]
-  );
+  let isValid = false
+
+  if (!ignoreChecksum) {
+    // calculate the hash and do the checksum byte checks
+    const hash = sshash(decoded.subarray(0, length));
+    isValid = (decoded[0] & 0x80) === 0 && ![46, 47].includes(decoded[0]) && (
+      isPublicKey
+        ? decoded[decoded.length - 2] === hash[0] && decoded[decoded.length - 1] === hash[1]
+        : decoded[decoded.length - 1] === hash[0]
+    )
+  }
 
   return [isValid, length, ss58Length, ss58Decoded];
 }
@@ -105,7 +109,7 @@ export function decodeSubstrateAddress(address: string, ignoreChecksum?: boolean
       throw realError
     }
 
-    const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded)
+    const [isValid, endPos, ss58Length, ss58Decoded] = checkAddressChecksum(decoded, ignoreChecksum)
 
     if (!ignoreChecksum && !isValid) {
       realError = new Error(`Invalid decoded address checksum`)
@@ -122,7 +126,8 @@ export function decodeSubstrateAddress(address: string, ignoreChecksum?: boolean
     return {
       u8a: publicKey,
       hex,
-      bigint: BigInt(hex)
+      bigint: BigInt(hex),
+      ss58Prefix: ss58Decoded,
     }
   } catch (error) {
     throw realError
@@ -132,7 +137,7 @@ export function decodeSubstrateAddress(address: string, ignoreChecksum?: boolean
 }
 
 type SubAddressObj = { Substrate: string }
-export const compareSubstrateAddresses = (address1: string | SubAddressObj | object, address2: string | SubAddressObj | object): boolean => {
+export const compareSubstrateAddresses = (address1: string | object, address2: string | object): boolean => {
   const addr1 = typeof address1 === 'string'
     ? address1
     : ((address1 as SubAddressObj).Substrate || (address1 as any).substrate) as string | undefined

src/Address/substrate.ts

@@ -7,3 +7,5 @@ export {
   StringUtils,
   constants,
 }
+
+export * from './types'