tronwb 6.0.0

package/src/types/TronWeb.ts

@@ -0,0 +1,23 @@
+import { AxiosRequestHeaders } from 'axios';
+import { BigNumber } from 'bignumber.js';
+import type { HeadersType } from './Providers.js';
+import HttpProvider from '../lib/providers/HttpProvider.js';
+
+export type IBigNumber = InstanceType<typeof BigNumber>;
+
+export interface TronWebOptions {
+    fullNode?: NodeProvider;
+    solidityNode?: NodeProvider;
+    fullHost?: NodeProvider;
+    eventServer?: NodeProvider;
+    headers?: HeadersType;
+    eventHeaders?: AxiosRequestHeaders;
+    privateKey?: string;
+    disablePlugins?: boolean;
+}
+export interface DefaultAddress {
+    hex: string | false;
+    base58: string | false;
+}
+
+export type NodeProvider = string | HttpProvider;

package/src/types/Trx.ts

@@ -0,0 +1,285 @@
+import { AccountType, Permission } from './Contract.js';
+import { SignedTransaction, Transaction } from './Transaction.js';
+import { Resource } from './TransactionBuilder.js';
+
+type HTTPMap<T extends string | number | symbol, U> = Record<T, U>[];
+
+export interface FrozenSupply {
+    frozen_amount: number;
+    frozen_days: number;
+}
+
+export interface Token {
+    id: string;
+    owner_address: string;
+    name: string;
+    abbr: string;
+    total_supply: number;
+    frozen_supply: FrozenSupply[];
+    trx_num: number;
+    precision: number;
+    num: number;
+    start_time: number;
+    end_time: number;
+    order: number; // useless
+    vote_score: number;
+    description: string;
+    url: string;
+    free_asset_net_limit: number;
+    public_free_asset_net_limit: number;
+    public_free_asset_net_usage: number;
+    public_latest_free_net_time: number;
+}
+
+export interface Frozen {
+    frozen_balance: number;
+    expire_time: number;
+}
+
+export interface Vote {
+    vote_address: string;
+    vote_count: number;
+}
+
+export interface AccountResource {
+    energy_usage: number;
+    frozen_balance_for_energy: Frozen;
+    latest_consume_time_for_energy: number;
+    acquired_delegated_frozen_balance_for_energy: number;
+    delegated_frozen_balance_for_energy: number;
+    storage_limit: number;
+    storage_usage: number;
+    latest_exchange_storage_time: number;
+    energy_window_size: number;
+    delegated_frozenV2_balance_for_energy: number;
+    acquired_delegated_frozenV2_balance_for_energy: number;
+    energy_window_optimized: boolean;
+}
+
+export enum ResourceCode {
+    BANDWIDTH = 0x00,
+    ENERGY = 0x01,
+    TRON_POWER = 0x02,
+}
+
+export interface FreezeV2 {
+    type: Resource;
+    amount: number;
+}
+export interface UnFreezeV2 {
+    type: Resource;
+    unfreeze_amount: number;
+    unfreeze_expire_time: number;
+}
+
+export interface Account {
+    account_name: string;
+    type: AccountType;
+    address: string;
+    balance: number;
+    votes: Vote[];
+    asset: HTTPMap<string, number>;
+    assetV2: HTTPMap<string, number>;
+    frozen: Frozen[];
+    net_usage: number;
+    acquired_delegated_frozen_balance_for_bandwidth: number;
+    delegated_frozen_balance_for_bandwidth: number;
+    old_tron_power: number;
+    tron_power: Frozen;
+    asset_optimized: boolean;
+    create_time: number;
+    latest_opration_time: number;
+    allowance: number;
+    latest_withdraw_time: number;
+    code: string;
+    is_witness: boolean;
+    is_committee: boolean;
+    frozen_supply: Frozen;
+    asset_issued_name: string;
+    asset_issued_ID: string;
+    latest_asset_operation_time: HTTPMap<string, number>;
+    latest_asset_operation_timeV2: HTTPMap<string, number>;
+    free_net_usage: number;
+    free_asset_net_usage: HTTPMap<string, number>;
+    free_asset_net_usageV2: HTTPMap<string, number>;
+    latest_consume_time: number;
+    latest_consume_free_time: number;
+    account_id: string;
+    net_window_size: number;
+    net_window_optimized: number;
+    account_resource: AccountResource;
+    codeHash: string;
+    owner_permission: Permission;
+    witness_permission: Permission;
+    active_permission: Permission[];
+    frozenV2: FreezeV2[];
+    unfrozenV2: UnFreezeV2[];
+    delegated_frozenV2_balance_for_bandwidth: number;
+    acquired_delegated_frozenV2_balance_for_bandwidth: number;
+}
+
+export interface AccountNetMessage {
+    freeNetUsed: number;
+    freeNetLimit: number;
+    NetUsed: number;
+    NetLimit: number;
+    assetNetUsed: HTTPMap<string, number>;
+    assetNetLimit: HTTPMap<string, number>;
+    TotalNetLimit: number;
+    TotalNetWeight: number;
+}
+
+export interface Witness {
+    address: string;
+    voteCount: number;
+    pubKey: string;
+    url: string;
+    totalProduced: number;
+    totalMissed: number;
+    latestBlockNum: number;
+    latestSlotNum: number;
+    isJobs: boolean;
+}
+
+enum TransactionSignWeight_response_code {
+    ENOUGH_PERMISSION = 'ENOUGH_PERMISSION',
+    NOT_ENOUGH_PERMISSION = 'NOT_ENOUGH_PERMISSION', // error in
+    SIGNATURE_FORMAT_ERROR = 'SIGNATURE_FORMAT_ERROR',
+    COMPUTE_ADDRESS_ERROR = 'COMPUTE_ADDRESS_ERROR',
+    PERMISSION_ERROR = 'PERMISSION_ERROR', //The key is not in permission
+    OTHER_ERROR = 'OTHER_ERROR',
+}
+
+interface TransactionSignWeightResult {
+    code: TransactionSignWeight_response_code;
+    message: string;
+}
+
+export interface TransactionSignWeight {
+    permission: Permission;
+    approved_list: string[];
+    current_weight: number;
+    result: TransactionSignWeightResult;
+    transaction: { transaction: Transaction };
+}
+
+enum BroadcastReturn_response_code {
+    SUCCESS = 0,
+    SIGERROR = 1, // error in signature
+    CONTRACT_VALIDATE_ERROR = 2,
+    CONTRACT_EXE_ERROR = 3,
+    BANDWITH_ERROR = 4,
+    DUP_TRANSACTION_ERROR = 5,
+    TAPOS_ERROR = 6,
+    TOO_BIG_TRANSACTION_ERROR = 7,
+    TRANSACTION_EXPIRATION_ERROR = 8,
+    SERVER_BUSY = 9,
+    NO_CONNECTION = 10,
+    NOT_ENOUGH_EFFECTIVE_CONNECTION = 11,
+    OTHER_ERROR = 20,
+}
+
+export interface BroadcastReturn<T extends SignedTransaction> {
+    result: boolean;
+    code: BroadcastReturn_response_code;
+    message: string;
+    transaction: T;
+}
+
+export interface BroadcastHexReturn {
+    result: boolean;
+    txid: string;
+    code: string;
+    message: string;
+    transaction: string;
+}
+
+export interface AddressOptions {
+    privateKey?: string;
+    address?: string;
+}
+
+enum ProposalState {
+    PENDING = 0,
+    DISAPPROVED = 1,
+    APPROVED = 2,
+    CANCELED = 3,
+}
+
+export interface Proposal {
+    proposal_id: number;
+    proposer_address: string;
+    parameters: HTTPMap<number, number>;
+    expiration_time: number;
+    create_time: number;
+    approvals: string[];
+    state: ProposalState;
+}
+
+export interface ChainParameter {
+    key: string;
+    value: number;
+}
+
+export interface AccountResourceMessage {
+    freeNetUsed: number;
+    freeNetLimit: number;
+    NetUsed: number;
+    NetLimit: number;
+    assetNetUsed: HTTPMap<string, number>;
+    assetNetLimit: HTTPMap<string, number>;
+    TotalNetLimit: number;
+    TotalNetWeight: number;
+    TotalTronPowerWeight: number;
+    tronPowerUsed: number;
+    tronPowerLimit: number;
+    EnergyUsed: number;
+    EnergyLimit: number;
+    TotalEnergyLimit: number;
+    TotalEnergyWeight: number;
+    storageUsed: number;
+    storageLimit: number;
+}
+
+export type Address = string;
+
+export interface Exchange {
+    exchange_id: number;
+    creator_address: Address;
+    create_time: number;
+    first_token_id: string;
+    first_token_balance: number;
+    second_token_id: string;
+    second_token_balance: number;
+}
+
+export interface TransactionInfo {
+    id: string;
+    fee: number;
+    blockNumber: number;
+    blockTimeStamp: number;
+    contractResult: string[];
+    contract_address: string;
+    receipt: {
+        energy_usage: number;
+        energy_fee: number;
+        origin_energy_usage: number;
+        energy_usage_total: number;
+        net_usage: number;
+        net_fee: number;
+        result: string;
+        energy_penalty_total: number;
+    };
+    log: {
+        address: Address;
+        topics: string[];
+        data: string;
+    }[];
+    result?: 'FAILED';
+    resMessage: string;
+    withdraw_amount: number;
+    unfreeze_amount: number;
+    withdraw_expire_amount: number;
+    cancel_unfreezeV2_amount: HTTPMap<string, number>;
+    exchange_id: string;
+}

package/src/types/UtilsTypes.ts

@@ -0,0 +1,25 @@
+export type BytesLike = number[] | Uint8Array;
+
+export type EventQueryDataType = {
+    block_number: number;
+    block_timestamp: number;
+    contract_address: string;
+    event_name: string;
+    transaction_id: string;
+    result: unknown;
+    resource_Node: string;
+    _unconfirmed?: boolean;
+    _fingerprint?: string | undefined;
+};
+
+export type MapEventQueryDataType = {
+    block: number;
+    timestamp: number;
+    contract: string;
+    name: string;
+    transaction: string;
+    result: unknown;
+    resourceNode: string;
+    unconfirmed?: boolean;
+    fingerprint?: string | undefined;
+};

package/src/types/index.ts

@@ -0,0 +1,9 @@
+export * from './ABI.js';
+export * from './APIResponse.js';
+export * from './Contract.js';
+export * from './Providers.js';
+export * from './Transaction.js';
+export * from './TransactionBuilder.js';
+export * from './TronWeb.js';
+export * from './Trx.js';
+export * from './UtilsTypes.js';

package/src/types/interface.d.ts

@@ -0,0 +1 @@
+declare function parseInt(string: string | number, radix?: number | undefined): number;

package/src/utils/abi.ts

@@ -0,0 +1,257 @@
+import { AbiCoder } from './ethersUtils.js';
+import { TronWeb } from '../tronweb.js';
+import { ADDRESS_PREFIX, ADDRESS_PREFIX_REGEX } from './address.js';
+import { FunctionFragment, AbiParamsCommon, AbiInputsType } from '../types/ABI.js';
+
+const abiCoder = new AbiCoder();
+
+function _addressToHex(value: string) {
+    return TronWeb.address.toHex(value).replace(ADDRESS_PREFIX_REGEX, '0x');
+}
+
+export function decodeParams(names: string[], types: string[], output: string, ignoreMethodHash = false) {
+    if (ignoreMethodHash && output.replace(/^0x/, '').length % 64 === 8) output = '0x' + output.replace(/^0x/, '').substring(8);
+
+    if (output.replace(/^0x/, '').length % 64) {
+        throw new Error('The encoded string is not valid. Its length must be a multiple of 64.');
+    }
+
+    // workaround for unsupported trcToken type
+    types = types.map((type) => {
+        if (/trcToken/.test(type)) {
+            type = type.replace(/trcToken/, 'uint256');
+        }
+        return type;
+    });
+
+    return abiCoder.decode(types, output).reduce(
+        (obj, arg, index) => {
+            if (types[index] == 'address') {
+                arg = ADDRESS_PREFIX + arg.substr(2).toLowerCase();
+            }
+
+            if (names.length) {
+                obj[names[index]] = arg;
+            } else {
+                obj.push(arg);
+            }
+
+            return obj;
+        },
+        names.length ? {} : []
+    );
+}
+
+export function encodeParams(types: string[], values: any[]) {
+    for (let i = 0; i < types.length; i++) {
+        if (types[i] === 'address') {
+            values[i] = TronWeb.address.toHex(values[i]).replace(ADDRESS_PREFIX_REGEX, '0x');
+        }
+    }
+
+    return abiCoder.encode(types, values);
+}
+
+function extractSize(type: string) {
+    const size = type.match(/([a-zA-Z0-9])(\[.*\])/);
+    return size ? size[2] : '';
+}
+
+function extractArrayDim(type: string) {
+    const size = extractSize(type);
+    return (size.match(/\]\[/g) || []).length + 1;
+}
+
+export function encodeParamsV2ByABI(funABI: FunctionFragment, args: any[]) {
+    const types: string[] = [];
+
+    const buildFullTypeDefinition = (typeDef: AbiParamsCommon): string => {
+        if (typeDef && typeDef.type.indexOf('tuple') === 0 && typeDef.components) {
+            const innerTypes = typeDef.components.map((innerType: AbiParamsCommon) => {
+                return buildFullTypeDefinition(innerType);
+            });
+            return `tuple(${innerTypes.join(',')})${extractSize(typeDef.type)}`;
+        }
+
+        if (/trcToken/.test(typeDef.type)) return typeDef.type.replace(/trcToken/, 'uint256');
+
+        return typeDef.type;
+    };
+
+    const convertTypes = (types: string[]) => {
+        for (let i = 0; i < types.length; i++) {
+            const type = types[i];
+            if (/trcToken/.test(type)) types[i] = type.replace(/trcToken/, 'uint256');
+        }
+    };
+
+    const convertAddresses = (addrArr: string | string[]) => {
+        if (Array.isArray(addrArr)) {
+            addrArr.forEach((addrs, i) => {
+                addrArr[i] = convertAddresses(addrs) as string;
+            });
+            return addrArr;
+        } else {
+            return _addressToHex(addrArr);
+        }
+    };
+
+    const mapTuple = (components: ReadonlyArray<FunctionFragment>, args: any[], dimension: number) => {
+        if (dimension > 1) {
+            if (args.length) {
+                args.forEach((arg) => {
+                    mapTuple(components, arg, dimension - 1);
+                });
+            }
+        } else {
+            if (args.length && dimension) {
+                args.forEach((arg) => {
+                    encodeArgs(components, arg);
+                });
+            }
+        }
+    };
+
+    const encodeArgs = (inputs: ReadonlyArray<AbiParamsCommon> = [], args: any[]) => {
+        if (inputs.length)
+            inputs.forEach((input: AbiParamsCommon, i: number) => {
+                const type = input.type;
+
+                if (args[i])
+                    if (type === 'address') args[i] = _addressToHex(args[i]);
+                    else if (type.match(/^([^\x5b]*)(\x5b|$)/)![0] === 'address[') convertAddresses(args[i]);
+                    else if (type.indexOf('tuple') === 0)
+                        if (extractSize(type)) {
+                            const dimension = extractArrayDim(type);
+                            mapTuple(input.components!, args[i], dimension);
+                        } else encodeArgs(input.components!, args[i]);
+            });
+    };
+
+    if (funABI.inputs && funABI.inputs.length) {
+        for (let i = 0; i < funABI.inputs.length; i++) {
+            const type = funABI.inputs[i].type;
+            // "false" will be converting to `false` and "true" will be working
+            // fine as abiCoder assume anything in quotes as `true`
+            if (type === 'bool' && args[i] === 'false') {
+                args[i] = false;
+            }
+            types.push(type.indexOf('tuple') === 0 ? buildFullTypeDefinition(funABI.inputs[i]) : type);
+            if (args.length < types.length) {
+                args.push('');
+            }
+        }
+    }
+
+    encodeArgs(funABI.inputs, args);
+    convertTypes(types);
+
+    return abiCoder.encode(types, args);
+}
+
+export function decodeParamsV2ByABI(funABI: FunctionFragment | AbiInputsType, data: string | Uint8Array) {
+    const convertTypeNames = (types: string[]) => {
+        for (let i = 0; i < types.length; i++) {
+            const type = types[i];
+            if (/^trcToken/.test(type)) types[i] = type.replace(/^trcToken/, 'uint256');
+        }
+    };
+
+    const convertAddresses = (addrArr: string | string[]) => {
+        if (Array.isArray(addrArr)) {
+            addrArr.forEach((addrs, i) => {
+                addrArr[i] = convertAddresses(addrs) as string;
+            });
+            return addrArr;
+        } else {
+            return TronWeb.address.toHex(addrArr);
+        }
+    };
+
+    const mapTuple = (components: ReadonlyArray<AbiParamsCommon>, args: string[] | string[][], dimension: number) => {
+        if (dimension > 1) {
+            if (args.length) {
+                args.forEach((arg) => {
+                    mapTuple(components, arg as string[], dimension - 1);
+                });
+            }
+        } else {
+            if (args.length && dimension) {
+                args.forEach((arg) => {
+                    decodeResult(components, arg as string[]);
+                });
+            }
+        }
+    };
+
+    const buildFullTypeNameDefinition = (typeDef: AbiParamsCommon): string => {
+        const name = typeDef.name ? ` ${typeDef.name}` : '';
+        if (typeDef && typeDef.type.indexOf('tuple') === 0 && typeDef.components) {
+            const innerTypes = typeDef.components.map((innerType) => {
+                return buildFullTypeNameDefinition(innerType);
+            });
+            return `tuple(${innerTypes.join(',')})${extractSize(typeDef.type)}${name}`;
+        }
+        if (/trcToken/.test(typeDef.type)) return typeDef.type.replace(/trcToken/, 'uint256') + name;
+
+        return typeDef.type + name;
+    };
+
+    const decodeResult = (outputs: ReadonlyArray<AbiParamsCommon>, result: any[]) => {
+        if (outputs.length)
+            outputs.forEach((output, i) => {
+                const { type, name } = output;
+
+                if (result[i]) {
+                    if (type === 'address') {
+                        result[i] = TronWeb.address.toHex(result[i]);
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        if (name) result[name] = TronWeb.address.toHex(result[i]);
+                    } else if (type.match(/^([^\x5b]*)(\x5b|$)/)![0] === 'address[') {
+                        convertAddresses(result[i]);
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        if (name) result[name] = convertAddresses(result[i]);
+                    } else if (type.indexOf('tuple') === 0) {
+                        if (extractSize(type)) {
+                            const dimension = extractArrayDim(type);
+                            mapTuple(output.components!, result[i], dimension);
+                        } else decodeResult(output.components!, result[i]);
+
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        if (name) result[name] = result[i];
+                    } else {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        //@ts-ignore
+                        if (name) result[name] = result[i];
+                    }
+                } else {
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    //@ts-ignore
+                    if (name) result[name] = result[i];
+                }
+            });
+    };
+
+    // Only decode if there supposed to be fields
+    if ('outputs' in funABI && funABI.outputs && funABI.outputs.length > 0) {
+        const outputTypes: any[] = [];
+        for (let i = 0; i < funABI.outputs.length; i++) {
+            const type = funABI.outputs[i].type;
+            const name = funABI.outputs[i].name ? ` ${funABI.outputs[i].name}` : '';
+            outputTypes.push(type.indexOf('tuple') === 0 ? buildFullTypeNameDefinition(funABI.outputs[i]) : type + name);
+        }
+        convertTypeNames(outputTypes);
+
+        if (!data || !data.length) data = new Uint8Array(32 * funABI.outputs.length); // ensuring the data is at least filled by 0 cause `AbiCoder` throws if there's not engouh data
+        // decode data
+        const decodeRes = abiCoder.decode(outputTypes, data);
+        const decodeResCopy = decodeRes.toArray(true);
+        decodeResult(funABI.outputs, decodeResCopy);
+
+        return decodeResCopy;
+    }
+    return [];
+}

package/src/utils/accounts.ts

@@ -0,0 +1,60 @@
+import { byteArray2hexStr } from './bytes.js';
+import { getBase58CheckAddress, genPriKey, getAddressFromPriKey, getPubKeyFromPriKey, pkToAddress } from './crypto.js';
+import { ethersHDNodeWallet, Mnemonic, Wordlist } from './ethersUtils.js';
+import { TRON_BIP39_PATH_INDEX_0 } from './address.js';
+
+const INVALID_TRON_PATH_ERROR_MSG = 'Invalid tron path provided';
+
+export function generateAccount() {
+    const priKeyBytes = genPriKey();
+    const pubKeyBytes = getPubKeyFromPriKey(priKeyBytes);
+    const addressBytes = getAddressFromPriKey(priKeyBytes);
+
+    const privateKey = byteArray2hexStr(priKeyBytes);
+    const publicKey = byteArray2hexStr(pubKeyBytes);
+
+    return {
+        privateKey,
+        publicKey,
+        address: {
+            base58: getBase58CheckAddress(addressBytes),
+            hex: byteArray2hexStr(addressBytes),
+        },
+    };
+}
+
+export function generateRandom(password = '', path = TRON_BIP39_PATH_INDEX_0, wordlist?: Wordlist) {
+    const account = ethersHDNodeWallet.createRandom(password, path, wordlist);
+
+    const result = {
+        mnemonic: account.mnemonic,
+        privateKey: account.privateKey,
+        publicKey: account.signingKey.publicKey,
+        address: pkToAddress(account.privateKey.replace(/^0x/, '')),
+        path: account.path,
+    };
+
+    return result;
+}
+
+export function generateAccountWithMnemonic(
+    mnemonic: string,
+    path: string = TRON_BIP39_PATH_INDEX_0,
+    password: string | null | undefined = '',
+    wordlist: Wordlist | null = null
+) {
+    // eslint-disable-next-line no-useless-escape
+    if (!String(path).match(/^m\/44\'\/195\'/)) {
+        throw new Error(INVALID_TRON_PATH_ERROR_MSG);
+    }
+    const account = ethersHDNodeWallet.fromMnemonic(Mnemonic.fromPhrase(mnemonic, password, wordlist), path);
+
+    const result = {
+        mnemonic: account.mnemonic,
+        privateKey: account.privateKey,
+        publicKey: account.signingKey.publicKey,
+        address: pkToAddress(account.privateKey.replace(/^0x/, '')),
+    };
+
+    return result;
+}