tronwb 6.0.0

package/src/utils/address.ts

@@ -0,0 +1,89 @@
+import { hexStr2byteArray, byteArray2hexStr } from './code.js';
+import { decodeBase58Address, getBase58CheckAddress, isAddressValid, pkToAddress } from './crypto.js';
+import { isHex, isString } from './validations.js';
+import { keccak256 } from './ethersUtils.js';
+
+export const ADDRESS_SIZE = 34;
+export const ADDRESS_PREFIX = '41';
+export const ADDRESS_PREFIX_BYTE = 0x41;
+export const ADDRESS_PREFIX_REGEX = /^(41)/;
+
+export const TRON_BIP39_PATH_PREFIX = "m/44'/195'";
+export const TRON_BIP39_PATH_INDEX_0 = TRON_BIP39_PATH_PREFIX + "/0'/0/0";
+
+export function fromHex(address: string) {
+    if (!isHex(address)) return address;
+
+    return getBase58CheckAddress(hexStr2byteArray(address.replace(/^0x/, ADDRESS_PREFIX)));
+}
+
+export function toHex(address: string) {
+    if (isHex(address)) return address.toLowerCase().replace(/^0x/, ADDRESS_PREFIX);
+
+    return byteArray2hexStr(decodeBase58Address(address) as number[]).toLowerCase();
+}
+
+function getChecksumAddress(address: string): string {
+    address = address.toLowerCase();
+
+    const chars = address.substring(2).split('');
+
+    const expanded = new Uint8Array(40);
+    for (let i = 0; i < 40; i++) {
+        expanded[i] = chars[i].charCodeAt(0);
+    }
+
+    const hashed = hexStr2byteArray(keccak256(expanded).slice(2));
+
+    for (let i = 0; i < 40; i += 2) {
+        if ((hashed[i >> 1] >> 4) >= 8) {
+            chars[i] = chars[i].toUpperCase();
+        }
+        if ((hashed[i >> 1] & 0x0f) >= 8) {
+            chars[i + 1] = chars[i + 1].toUpperCase();
+        }
+    }
+
+    return ADDRESS_PREFIX + chars.join('');
+}
+
+export function toChecksumAddress(address: string) {
+    if (!isAddress(address)) throw new Error(`'${address}' is not a valid address string`);
+    return getChecksumAddress(toHex(address));
+}
+
+export function isChecksumAddress(address: string) {
+    if (!isHex(address) || address.length !== 42) return false;
+    try {
+        return toChecksumAddress(address) === address;
+    } catch {
+        return false;
+    }
+}
+
+export function fromPrivateKey(privateKey: string, strict = false) {
+    try {
+        return pkToAddress(privateKey, strict);
+    } catch {
+        return false;
+    }
+}
+
+export function isAddress(address: unknown): boolean {
+    if (!address || !isString(address)) return false;
+
+    // Convert HEX to Base58
+    if (address.length === 42) {
+        try {
+            // it throws an error if the address starts with 0x
+            return isAddress(getBase58CheckAddress(hexStr2byteArray(address)));
+        } catch (err) {
+            return false;
+        }
+    }
+    try {
+        return isAddressValid(address);
+    } catch (err) {
+        return false;
+    }
+}

package/src/utils/base58.ts

@@ -0,0 +1,78 @@
+import type { BytesLike } from '../types/UtilsTypes.js';
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const ALPHABET_MAP = {} as Record<string, number>;
+
+for (let i = 0; i < ALPHABET.length; i++) ALPHABET_MAP[ALPHABET.charAt(i)] = i;
+
+const BASE = 58;
+
+export function encode58(buffer: BytesLike | string) {
+    if (buffer.length === 0) return '';
+
+    let i: number;
+    let j: number;
+
+    const digits = [0];
+
+    for (i = 0; i < buffer.length; i++) {
+        for (j = 0; j < digits.length; j++) digits[j] <<= 8;
+
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        digits[0] += buffer[i];
+        let carry = 0;
+
+        for (j = 0; j < digits.length; ++j) {
+            digits[j] += carry;
+            carry = (digits[j] / BASE) | 0;
+            digits[j] %= BASE;
+        }
+
+        while (carry) {
+            digits.push(carry % BASE);
+            carry = (carry / BASE) | 0;
+        }
+    }
+
+    for (i = 0; buffer[i] === 0 && i < buffer.length - 1; i++) digits.push(0);
+
+    return digits
+        .reverse()
+        .map((digit) => ALPHABET[digit])
+        .join('');
+}
+
+export function decode58(string: string) {
+    if (string.length === 0) return [];
+
+    let i;
+    let j;
+
+    const bytes = [0];
+
+    for (i = 0; i < string.length; i++) {
+        const c: string = string[i];
+
+        if (!(c in ALPHABET_MAP)) throw new Error('Non-base58 character');
+
+        for (j = 0; j < bytes.length; j++) bytes[j] *= BASE;
+
+        bytes[0] += ALPHABET_MAP[c];
+        let carry = 0;
+
+        for (j = 0; j < bytes.length; ++j) {
+            bytes[j] += carry;
+            carry = bytes[j] >> 8;
+            bytes[j] &= 0xff;
+        }
+
+        while (carry) {
+            bytes.push(carry & 0xff);
+            carry >>= 8;
+        }
+    }
+
+    for (i = 0; string[i] === '1' && i < string.length - 1; i++) bytes.push(0);
+
+    return bytes.reverse();
+}

package/src/utils/base64.ts

@@ -0,0 +1,200 @@
+import type { BytesLike } from '../types/UtilsTypes.js';
+
+const _keyStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+
+export class Base64 {
+    encode(input: string) {
+        let output = '';
+        let chr1: number;
+        let chr2: number;
+        let chr3: number;
+        let enc1: number;
+        let enc2: number;
+        let enc3: number;
+        let enc4: number;
+        let i = 0;
+
+        while (i < input.length) {
+            chr1 = input.charCodeAt(i++);
+            chr2 = input.charCodeAt(i++);
+            chr3 = input.charCodeAt(i++);
+
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+
+            if (isNaN(chr2)) enc3 = enc4 = 64;
+            else if (isNaN(chr3)) enc4 = 64;
+
+            output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
+        }
+
+        return output;
+    }
+
+    encodeIgnoreUtf8(inputBytes: BytesLike) {
+        let output = '';
+        let chr1: number;
+        let chr2: number;
+        let chr3: number;
+        let enc1: number;
+        let enc2: number;
+        let enc3: number;
+        let enc4: number;
+        let i = 0;
+
+        while (i < inputBytes.length) {
+            chr1 = inputBytes[i++];
+            chr2 = inputBytes[i++];
+            chr3 = inputBytes[i++];
+
+            enc1 = chr1 >> 2;
+            enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+            enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+            enc4 = chr3 & 63;
+
+            if (isNaN(chr2)) enc3 = enc4 = 64;
+            else if (isNaN(chr3)) enc4 = 64;
+
+            output = output + _keyStr.charAt(enc1) + _keyStr.charAt(enc2) + _keyStr.charAt(enc3) + _keyStr.charAt(enc4);
+        }
+
+        return output;
+    }
+
+    decode(input: string) {
+        let output = '';
+        let chr1: number;
+        let chr2: number;
+        let chr3: number;
+        let enc1: number;
+        let enc2: number;
+        let enc3: number;
+        let enc4: number;
+        let i = 0;
+
+        // eslint-disable-next-line no-useless-escape
+        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+
+        while (i < input.length) {
+            enc1 = _keyStr.indexOf(input.charAt(i++));
+            enc2 = _keyStr.indexOf(input.charAt(i++));
+            enc3 = _keyStr.indexOf(input.charAt(i++));
+            enc4 = _keyStr.indexOf(input.charAt(i++));
+
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+
+            output = output + String.fromCharCode(chr1);
+
+            if (enc3 != 64) output = output + String.fromCharCode(chr2);
+
+            if (enc4 != 64) output = output + String.fromCharCode(chr3);
+        }
+
+        return this._utf8_decode(output);
+    }
+
+    decodeToByteArray(input: string) {
+        let output = '';
+        let chr1: number;
+        let chr2: number;
+        let chr3: number;
+        let enc1: number;
+        let enc2: number;
+        let enc3: number;
+        let enc4: number;
+        let i = 0;
+
+        // eslint-disable-next-line no-useless-escape
+        input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
+
+        while (i < input.length) {
+            enc1 = _keyStr.indexOf(input.charAt(i++));
+            enc2 = _keyStr.indexOf(input.charAt(i++));
+            enc3 = _keyStr.indexOf(input.charAt(i++));
+            enc4 = _keyStr.indexOf(input.charAt(i++));
+
+            chr1 = (enc1 << 2) | (enc2 >> 4);
+            chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+            chr3 = ((enc3 & 3) << 6) | enc4;
+
+            output = output + String.fromCharCode(chr1);
+
+            if (enc3 != 64) output = output + String.fromCharCode(chr2);
+
+            if (enc4 != 64) output = output + String.fromCharCode(chr3);
+        }
+
+        return this._out2ByteArray(output);
+    }
+
+    _out2ByteArray(utftext: string) {
+        const byteArray: BytesLike = new Array(utftext.length);
+
+        let i = 0;
+        let c = 0;
+
+        while (i < utftext.length) {
+            c = utftext.charCodeAt(i);
+            byteArray[i] = c;
+            i++;
+        }
+
+        return byteArray;
+    }
+
+    _utf8_encode(string: string) {
+        string = string.replace(/\r\n/g, '\n');
+        let utftext = '';
+
+        for (let n = 0; n < string.length; n++) {
+            const c = string.charCodeAt(n);
+
+            if (c < 128) {
+                utftext += String.fromCharCode(c);
+            } else if (c > 127 && c < 2048) {
+                utftext += String.fromCharCode((c >> 6) | 192);
+                utftext += String.fromCharCode((c & 63) | 128);
+            } else {
+                utftext += String.fromCharCode((c >> 12) | 224);
+                utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+                utftext += String.fromCharCode((c & 63) | 128);
+            }
+        }
+
+        return utftext;
+    }
+
+    _utf8_decode(utftext: string) {
+        let string = '';
+        let i = 0;
+        let c = 0;
+        let c2 = 0;
+        let c3 = 0;
+
+        while (i < utftext.length) {
+            c = utftext.charCodeAt(i);
+
+            if (c < 128) {
+                string += String.fromCharCode(c);
+                i++;
+            } else if (c > 191 && c < 224) {
+                c2 = utftext.charCodeAt(i + 1);
+                string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+                i += 2;
+            } else {
+                c2 = utftext.charCodeAt(i + 1);
+                c3 = utftext.charCodeAt(i + 2);
+
+                string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+
+                i += 3;
+            }
+        }
+
+        return string;
+    }
+}

package/src/utils/bytes.ts

@@ -0,0 +1,68 @@
+import { Base64 } from './base64.js';
+import { BytesLike } from '../types/UtilsTypes.js';
+
+export function byte2hexStr(byte: number) {
+    if (byte < 0 || byte > 255) throw new Error('Input must be a byte');
+
+    const hexByteMap = '0123456789ABCDEF';
+
+    let str = '';
+    str += hexByteMap.charAt(byte >> 4);
+    str += hexByteMap.charAt(byte & 0x0f);
+
+    return str;
+}
+
+export function bytesToString(arr: BytesLike) {
+    let str = '';
+
+    for (let i = 0; i < arr.length; i++) {
+        const one = arr[i].toString(2);
+        const v = one.match(/^1+?(?=0)/);
+
+        if (v && one.length === 8) {
+            const bytesLength = v[0].length;
+            let store = arr[i].toString(2).slice(7 - bytesLength);
+
+            for (let st = 1; st < bytesLength; st++) store += arr[st + i].toString(2).slice(2);
+
+            str += String.fromCharCode(parseInt(store, 2));
+            i += bytesLength - 1;
+        } else {
+            str += String.fromCharCode(arr[i]);
+        }
+    }
+
+    return str;
+}
+
+export function hextoString(hex: string) {
+    const arr = hex.replace(/^0x/, '').split('');
+    let out = '';
+
+    for (let i = 0; i < arr.length / 2; i++) {
+        const tmp = `0x${arr[i * 2]}${arr[i * 2 + 1]}`;
+        out += String.fromCharCode(parseInt(tmp));
+    }
+
+    return out;
+}
+
+export function byteArray2hexStr(byteArray: BytesLike) {
+    let str = '';
+
+    for (let i = 0; i < byteArray.length; i++) str += byte2hexStr(byteArray[i]);
+
+    return str;
+}
+
+export function base64DecodeFromString(string64: string) {
+    return new Base64().decodeToByteArray(string64);
+}
+
+export function base64EncodeToString(bytes: BytesLike) {
+    const b = new Base64();
+    const string64 = b.encodeIgnoreUtf8(bytes);
+
+    return string64;
+}

package/src/utils/code.ts

@@ -0,0 +1,172 @@
+import {
+    byte2hexStr,
+    bytesToString,
+    hextoString,
+    byteArray2hexStr,
+    base64DecodeFromString,
+    base64EncodeToString,
+} from './bytes.js';
+
+import type { BytesLike } from '../types/UtilsTypes.js';
+
+export function bin2String(array: BytesLike) {
+    return bytesToString(array);
+}
+
+export function arrayEquals(array1: any[], array2: any[], strict = false) {
+    if (array1.length != array2.length) return false;
+
+    for (let i = 0; i < array1.length; i++) {
+        if (strict) {
+            if (array1[i] != array2[i]) return false;
+        } else if (JSON.stringify(array1[i]) != JSON.stringify(array2[i])) return false;
+    }
+
+    return true;
+}
+
+export function stringToBytes(str: string) {
+    const bytes = [];
+    const len: number = str.length;
+    let c: number;
+
+    for (let i = 0; i < len; i++) {
+        c = str.charCodeAt(i);
+
+        if (c >= 0x010000 && c <= 0x10ffff) {
+            bytes.push(((c >> 18) & 0x07) | 0xf0);
+            bytes.push(((c >> 12) & 0x3f) | 0x80);
+            bytes.push(((c >> 6) & 0x3f) | 0x80);
+            bytes.push((c & 0x3f) | 0x80);
+        } else if (c >= 0x000800 && c <= 0x00ffff) {
+            bytes.push(((c >> 12) & 0x0f) | 0xe0);
+            bytes.push(((c >> 6) & 0x3f) | 0x80);
+            bytes.push((c & 0x3f) | 0x80);
+        } else if (c >= 0x000080 && c <= 0x0007ff) {
+            bytes.push(((c >> 6) & 0x1f) | 0xc0);
+            bytes.push((c & 0x3f) | 0x80);
+        } else bytes.push(c & 0xff);
+    }
+
+    return bytes;
+}
+
+export { byte2hexStr, bytesToString, hextoString, byteArray2hexStr, base64DecodeFromString, base64EncodeToString };
+
+export function hexChar2byte(c: string) {
+    let d: number | undefined;
+
+    if (c >= 'A' && c <= 'F') d = c.charCodeAt(0) - 'A'.charCodeAt(0) + 10;
+    else if (c >= 'a' && c <= 'f') d = c.charCodeAt(0) - 'a'.charCodeAt(0) + 10;
+    else if (c >= '0' && c <= '9') d = c.charCodeAt(0) - '0'.charCodeAt(0);
+
+    if (typeof d === 'number') return d;
+    else throw new Error('The passed hex char is not a valid hex char');
+}
+
+export function isHexChar(c: string) {
+    if ((c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f') || (c >= '0' && c <= '9')) {
+        return 1;
+    }
+
+    return 0;
+}
+
+// set strict as true: if the length of str is odd, add 0 before the str to make its length as even
+export function hexStr2byteArray(str: string, strict = false) {
+    let len = str.length;
+
+    if (strict) {
+        if (len % 2) {
+            str = `0${str}`;
+            len++;
+        }
+    }
+    const byteArray: number[] = [];
+    let d = 0;
+    let j = 0;
+    let k = 0;
+
+    for (let i = 0; i < len; i++) {
+        const c = str.charAt(i);
+
+        if (isHexChar(c)) {
+            d <<= 4;
+            d += hexChar2byte(c);
+            j++;
+
+            if (0 === j % 2) {
+                byteArray[k++] = d;
+                d = 0;
+            }
+        } else throw new Error('The passed hex char is not a valid hex string');
+    }
+
+    return byteArray;
+}
+
+//yyyy-MM-DD HH-mm-ss
+export function strToDate(str: string) {
+    if (!/^\d{4}-\d{2}-\d{2}( \d{2}-\d{2}-\d{2}|)/.test(str)) throw new Error('The passed date string is not valid');
+
+    const tempStrs = str.split(' ');
+    const dateStrs = tempStrs[0].split('-');
+    const year = parseInt(dateStrs[0], 10);
+    const month = parseInt(dateStrs[1], 10) - 1;
+    const day = parseInt(dateStrs[2], 10);
+
+    if (tempStrs.length > 1) {
+        const timeStrs = tempStrs[1].split('-');
+        const hour = parseInt(timeStrs[0], 10);
+        const minute = parseInt(timeStrs[1], 10);
+        const second = parseInt(timeStrs[2], 10);
+
+        return new Date(year, month, day, hour, minute, second);
+    }
+
+    return new Date(year, month, day);
+}
+
+export function isNumber(c: string) {
+    if (c >= '0' && c <= '9') return 1;
+
+    return 0;
+}
+
+//return 1: address  --- 20Bytes HexString
+//return 2: blockNumber ------ Decimal number
+//return 3: assetName ------ String
+//return other: error
+export function getStringType(str: string) {
+    if (null == str) return -1;
+
+    if (str.length == 0 || str == '') return -1;
+
+    let i = 0;
+
+    if (str.length == 40) {
+        for (; i < 40; i++) {
+            const c = str.charAt(i);
+
+            if (!isHexChar(c)) break;
+        }
+    }
+
+    if (i == 40) return 1; //40 Hex, Address
+
+    for (i = 0; i < str.length; i++) {
+        const c = str.charAt(i);
+
+        if (!isNumber(c)) break;
+    }
+
+    if (i == str.length) return 2; // All Decimal number, BlockNumber
+
+    for (i = 0; i < str.length; i++) {
+        const c = str.charAt(i);
+
+        if (c > ' ') return 3; // At least one visible character
+    }
+
+    return -1;
+}