dotbit-sdk-allin/lib.esm/tools/account.js

A complete .bit SDK and utilities in TypeScript

import blake2b from 'blake2b';
import { pad0x } from './common';
import GraphemeSplitter from 'grapheme-splitter';
import emojiList from './char_set/emoji_list.json';
import numberList from './char_set/digit_list.json';
import englishList from './char_set/en_list.json';
import turkishList from './char_set/tr_list.json';
import thaiList from './char_set/th_list.json';
import koreanList from './char_set/ko_list.json';
import vietnameseList from './char_set/vi_list.json';
import { ACCOUNT_SUFFIX, CHAR_TYPE, languageToCharType, languages, DigitalEmojiUnifiedMap } from '../const';
export function isSupportedAccount(account) {
    return /^([^\.\s]+\.){1,}bit$/.test(account) && account.split(/.#/).every(v => Boolean(v.length));
}
export function toDottedStyle(inputAccount) {
    if (!isSupportedAccount(inputAccount)) {
        return inputAccount;
    }
    if (!inputAccount.includes('#')) {
        return inputAccount;
    }
    const [account, suffix] = inputAccount.split('.');
    const [main, sub] = account.split('#');
    return `${sub}.${main}.${suffix}`;
}
export function toHashedStyle(inputAccount) {
    if (!isSupportedAccount(inputAccount)) {
        return inputAccount;
    }
    if (inputAccount.includes('#')) {
        return inputAccount;
    }
    const parts = inputAccount.split('.');
    if (parts.length === 3) {
        const [sub, main, suffix] = parts;
        return `${main}#${sub}.${suffix}`;
    }
    return inputAccount;
}
export function accountIdHex(account) {
    const personal = Buffer.from('ckb-default-hash');
    const accountBuf = Buffer.from(account);
    const hasher = blake2b(32, null, null, personal);
    hasher.update(accountBuf);
    const hashBuffer = hasher.digest('binary');
    const first20Bytes = Buffer.from(hashBuffer.slice(0, 20));
    return pad0x(first20Bytes.toString('hex'));
}
export function toRecordExtended(record) {
    return Object.assign(Object.assign({}, record), { type: record.key.split('.')[0], subtype: record.key.split('.')[1] });
}
export function isSubAccount(account) {
    const subAccountPattern = /^([^\.\s]+\.){2,}bit$/;
    return subAccountPattern.test(account);
}
export function trimAccountSuffix(account) {
    return account.replace(/\.bit$/, '');
}
function getLanguageGraphemes(charSplit, language) {
    const languageToCharList = {
        en: englishList,
        tr: turkishList,
        vi: vietnameseList,
        th: thaiList,
        ko: koreanList
    };
    const charList = languageToCharList[language];
    const charInfos = [];
    const charTypes = [CHAR_TYPE.emoji, CHAR_TYPE.number, languageToCharType[language]];
    for (const char of charSplit) {
        let included = false;
        for (const [index, list] of [emojiList, numberList, charList].entries()) {
            if (list.includes(char)) {
                charInfos.push({
                    char_set_name: charTypes[index],
                    char
                });
                included = true;
                break;
            }
        }
        if (!included) {
            return null;
        }
    }
    return charInfos;
}
function getLanguage(language) {
    for (const languageStr of languages) {
        if (language.startsWith(languageStr)) {
            return language;
        }
    }
    return 'en';
}
export function digitalEmojiUnifiedHandle(str) {
    const splitter = new GraphemeSplitter();
    const split = splitter.splitGraphemes(str);
    const list = split.map((item) => {
        return DigitalEmojiUnifiedMap[item] || item;
    });
    return list.join('');
}
export function graphemesAccount(account, addSuffix = false, language = 'en') {
    const splitter = new GraphemeSplitter();
    let split = splitter.splitGraphemes(account);
    split = split.map((item) => {
        if (DigitalEmojiUnifiedMap[item]) {
            return DigitalEmojiUnifiedMap[item];
        }
        else {
            return item;
        }
    });
    language = getLanguage(language);
    let splitArr = null;
    const languageList = languages.filter(lang => lang !== language);
    languageList.unshift(language);
    for (const languageItem of languageList) {
        splitArr = getLanguageGraphemes(split, languageItem);
        if (splitArr !== null) {
            break;
        }
    }
    if (!splitArr) {
        splitArr = split.map((char) => {
            return {
                char_set_name: CHAR_TYPE.unknown,
                char
            };
        });
    }
    if (addSuffix) {
        ACCOUNT_SUFFIX.split('')
            .forEach((char) => {
            splitArr.push({
                char_set_name: CHAR_TYPE.english,
                char
            });
        });
    }
    return splitArr;
}
export function getAccountCharsetTypes(account) {
    const name = trimAccountSuffix(account);
    const graphemes = graphemesAccount(name);
    const charTypes = {};
    graphemes.forEach(grapheme => {
        charTypes[grapheme.char_set_name] = true;
    });
    return charTypes;
}
//# sourceMappingURL=account.js.map