update: remove web3 dependencies

lib/src/utils/address.ts

@@ -1,9 +1,8 @@
 import bech32 from 'bech32';
-import { isAddress } from 'web3-validator';
-import { stripHexPrefix } from 'web3-eth-accounts';
+import { keccak256 } from 'ethereum-cryptography/keccak';
+import { utf8ToBytes } from 'ethereum-cryptography/utils';
 import { Network } from '../network/network';
 import { Bytes } from './bytes/bytes';
-// import { toBase64 } from '@cosmjs/encoding';
 
 export interface AddressValidationProperties {
     address: string;
@@ -22,6 +21,140 @@ export enum AddressType {
  * @returns {boolean}
  * @throws {Error} when Bech32 encoding is not correct
  */
+
+export function isHexPrefixed(str: string): boolean {
+    if (typeof str !== 'string') {
+        throw new Error(`[isHexPrefixed] input must be type 'string', received type ${typeof str}`);
+    }
+
+    return str.startsWith('0x');
+}
+
+export function stripHexPrefix(str: string): string {
+    if (typeof str !== 'string')
+        throw new Error(`[stripHexPrefix] input must be type 'string', received ${typeof str}`);
+
+    return isHexPrefixed(str) ? str.slice(2) : str;
+}
+
+export function isUint8Array(data: unknown | Uint8Array): data is Uint8Array {
+    return (
+        data instanceof Uint8Array ||
+        (data as { constructor: { name: string } })?.constructor?.name === 'Uint8Array' ||
+        (data as { constructor: { name: string } })?.constructor?.name === 'Buffer'
+    );
+}
+
+export function uint8ArrayToHexString(uint8Array: Uint8Array): string {
+    return uint8Array.reduce((hexString, e) => {
+        const hex = e.toString(16);
+        return hexString + (hex.length === 1 ? `0${hex}` : hex);
+    }, '0x');
+}
+
+export function isHexStrict(hex: Uint8Array | bigint | string | number | boolean) {
+    return typeof hex === 'string' && /^((-)?0x[0-9a-f]+|(0x))$/i.test(hex);
+}
+
+export function ensureIfUint8Array<T = any>(data: T) {
+    if (
+        !(data instanceof Uint8Array) &&
+        (data as { constructor: { name: string } })?.constructor?.name === 'Uint8Array'
+    ) {
+        return Uint8Array.from((data as unknown) as Uint8Array);
+    }
+    return data;
+}
+
+export function checkAddressCheckSum(data: string): boolean {
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(data)) return false;
+    const address = data.slice(2);
+    const updatedData = utf8ToBytes(address.toLowerCase());
+
+    const addressHash = uint8ArrayToHexString(keccak256(ensureIfUint8Array(updatedData))).slice(2);
+
+    for (let i = 0; i < 40; i += 1) {
+        // the nth letter should be uppercase if the nth digit of casemap is 1
+        if (
+            (parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) ||
+            (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])
+        ) {
+            return false;
+        }
+    }
+    return true;
+}
+
+export const isAddress = (value: Uint8Array | bigint | string | number | boolean, checkChecksum = true) => {
+    if (typeof value !== 'string' && !isUint8Array(value)) {
+        return false;
+    }
+
+    let valueToCheck: string;
+
+    if (isUint8Array(value)) {
+        valueToCheck = uint8ArrayToHexString(value);
+    } else if (typeof value === 'string' && !isHexStrict(value)) {
+        valueToCheck = value.toLowerCase().startsWith('0x') ? value : `0x${value}`;
+    } else {
+        valueToCheck = value;
+    }
+
+    // check if it has the basic requirements of an address
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(valueToCheck)) {
+        return false;
+    }
+    // If it's ALL lowercase or ALL upppercase
+    if (/^(0x|0X)?[0-9a-f]{40}$/.test(valueToCheck) || /^(0x|0X)?[0-9A-F]{40}$/.test(valueToCheck)) {
+        return true;
+        // Otherwise check each case
+    }
+    return checkChecksum ? checkAddressCheckSum(valueToCheck) : true;
+};
+
+/**
+ * Checks if the given string is an address
+ *
+ * @method isAddress
+ * @param {String} address the given HEX adress
+ * @return {Boolean}
+ */
+// export function isAddress(address: string) {
+//     if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+//         // check if it has the basic requirements of an address
+//         return false;
+//     }
+//     if (/^(0x)?[0-9a-f]{40}$/.test(address) || /^(0x)?[0-9A-F]{40}$/.test(address)) {
+//         // If it's all small caps or all all caps, return true
+//         return true;
+//     }
+//     // Otherwise check each case
+//     return isChecksumAddress(address);
+// }
+
+// /**
+//  * Checks if the given string is a checksummed address
+//  *
+//  * @method isChecksumAddress
+//  * @param {String} address the given HEX adress
+//  * @return {Boolean}
+//  */
+// export function isChecksumAddress(address: string) {
+//     // Check each case
+//     const checkSumAddress = address.replace('0x', '');
+//     let addressHash = sha3(checkSumAddress.toLowerCase());
+//     for (let i = 0; i < 40; i++) {
+//         // the nth letter should be uppercase if the nth digit of casemap is 1
+//         if (
+//             (parseInt(addressHash[i], 16) > 7 && address[i].toUpperCase() !== address[i]) ||
+//             (parseInt(addressHash[i], 16) <= 7 && address[i].toLowerCase() !== address[i])
+//         ) {
+//             return false;
+//         }
+//     }
+//     return true;
+// }
+
 export function validateAddress(addressProps: AddressValidationProperties): boolean | never {
     const { network } = addressProps;
     const bech32Decoded = bech32.decode(addressProps.address);