tronwb 6.0.0

package/lib/commonjs/lib/providers/HttpProvider.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const axios_1 = tslib_1.__importDefault(require("axios"));
+const validations_js_1 = require("../../utils/validations.js");
+class HttpProvider {
+    host;
+    timeout;
+    user;
+    password;
+    headers;
+    statusPage;
+    instance;
+    constructor(host, timeout = 30000, user = '', password = '', headers = {}, statusPage = '/') {
+        if (!(0, validations_js_1.isValidURL)(host))
+            throw new Error('Invalid URL provided to HttpProvider');
+        if (isNaN(timeout) || timeout < 0)
+            throw new Error('Invalid timeout duration provided');
+        if (!(0, validations_js_1.isObject)(headers))
+            throw new Error('Invalid headers object provided');
+        host = host.replace(/\/+$/, '');
+        this.host = host;
+        this.timeout = timeout;
+        this.user = user;
+        this.password = password;
+        this.headers = headers;
+        this.statusPage = statusPage;
+        this.instance = axios_1.default.create({
+            baseURL: host,
+            timeout: timeout,
+            headers: headers,
+            auth: user
+                ? {
+                    username: user,
+                    password,
+                }
+                : undefined,
+        });
+    }
+    setStatusPage(statusPage = '/') {
+        this.statusPage = statusPage;
+    }
+    async isConnected(statusPage = this.statusPage) {
+        return this.request(statusPage)
+            .then((data) => {
+            return (0, validations_js_1.hasProperties)(data, 'blockID', 'block_header');
+        })
+            .catch(() => false);
+    }
+    request(url, payload = {}, method = 'get') {
+        method = method.toLowerCase();
+        return this.instance
+            .request({
+            data: method == 'post' && Object.keys(payload).length ? payload : null,
+            params: method == 'get' && payload,
+            url,
+            method,
+        })
+            .then(({ data }) => data);
+    }
+}
+exports.default = HttpProvider;
+//# sourceMappingURL=HttpProvider.js.map

package/lib/commonjs/lib/providers/HttpProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HttpProvider.js","sourceRoot":"","sources":["../../../../src/lib/providers/HttpProvider.ts"],"names":[],"mappings":";;;AAAA,0DAAsC;AACtC,+DAAiF;AAGjF,MAAqB,YAAY;IAC7B,IAAI,CAAS;IACb,OAAO,CAAS;IAChB,IAAI,CAAS;IACb,QAAQ,CAAS;IACjB,OAAO,CAAc;IACrB,UAAU,CAAS;IACnB,QAAQ,CAAuB;IAC/B,YAAY,IAAY,EAAE,OAAO,GAAG,KAAK,EAAE,IAAI,GAAG,EAAE,EAAE,QAAQ,GAAG,EAAE,EAAE,UAAuB,EAAE,EAAE,UAAU,GAAG,GAAG;QAC5G,IAAI,CAAC,IAAA,2BAAU,EAAC,IAAI,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;QAE/E,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,OAAO,GAAG,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,mCAAmC,CAAC,CAAC;QAExF,IAAI,CAAC,IAAA,yBAAQ,EAAC,OAAO,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;QAE3E,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QAEhC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAE7B,IAAI,CAAC,QAAQ,GAAG,eAAK,CAAC,MAAM,CAAC;YACzB,OAAO,EAAE,IAAI;YACb,OAAO,EAAE,OAAO;YAChB,OAAO,EAAE,OAAO;YAChB,IAAI,EAAE,IAAI;gBACN,CAAC,CAAC;oBACI,QAAQ,EAAE,IAAI;oBACd,QAAQ;iBACX;gBACH,CAAC,CAAC,SAAS;SAClB,CAAC,CAAC;IACP,CAAC;IAED,aAAa,CAAC,UAAU,GAAG,GAAG;QAC1B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU;QAC1C,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC;aAC1B,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE;YACX,OAAO,IAAA,8BAAa,EAAC,IAA8B,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC;QACpF,CAAC,CAAC;aACD,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,OAAO,CAAc,GAAW,EAAE,OAAO,GAAG,EAAE,EAAE,SAAiB,KAAK;QAClE,MAAM,GAAG,MAAM,CAAC,WAAW,EAAY,CAAC;QAExC,OAAO,IAAI,CAAC,QAAQ;aACf,OAAO,CAAI;YACR,IAAI,EAAE,MAAM,IAAI,MAAM,IAAI,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI;YACtE,MAAM,EAAE,MAAM,IAAI,KAAK,IAAI,OAAO;YAClC,GAAG;YACH,MAAM;SACT,CAAC;aACD,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC;IAClC,CAAC;CACJ;AA7DD,+BA6DC"}

package/lib/commonjs/lib/providers/index.d.ts

@@ -0,0 +1,6 @@
+import HttpProvider from './HttpProvider.js';
+export interface Providers {
+    HttpProvider: typeof HttpProvider;
+}
+export declare const providers: Providers;
+export { HttpProvider };

package/lib/commonjs/lib/providers/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpProvider = exports.providers = void 0;
+const tslib_1 = require("tslib");
+const HttpProvider_js_1 = tslib_1.__importDefault(require("./HttpProvider.js"));
+exports.HttpProvider = HttpProvider_js_1.default;
+exports.providers = { HttpProvider: HttpProvider_js_1.default };
+//# sourceMappingURL=index.js.map

package/lib/commonjs/lib/providers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/providers/index.ts"],"names":[],"mappings":";;;;AAAA,gFAA6C;AAKpC,uBALF,yBAAY,CAKE;AADR,QAAA,SAAS,GAAc,EAAE,YAAY,EAAZ,yBAAY,EAAE,CAAC"}

package/lib/commonjs/lib/trx.d.ts

@@ -0,0 +1,315 @@
+import { TronWeb } from '../tronweb.js';
+import { Block } from '../types/APIResponse.js';
+import { Token, Account, Witness, TransactionSignWeight, BroadcastReturn, AddressOptions, Proposal, ChainParameter, BroadcastHexReturn, AccountResourceMessage, Address, Exchange, TransactionInfo } from '../types/Trx.js';
+import { SignedTransaction, Transaction } from '../types/Transaction.js';
+import { TypedDataDomain, TypedDataField } from '../utils/typedData.js';
+import { Resource } from '../types/TransactionBuilder.js';
+type SignedStringOrSignedTransaction<T extends string | Transaction | SignedTransaction> = T extends string ? string : SignedTransaction & T;
+export declare class Trx {
+    private tronWeb;
+    private cache;
+    private validator;
+    signMessage: <T extends SignedTransaction | Transaction | string>(transaction: T, privateKey?: string | false, useTronHeader?: boolean, multisig?: boolean) => Promise<SignedStringOrSignedTransaction<T>>;
+    sendAsset: (to: string, amount: number, tokenID: string | number, options?: AddressOptions) => Promise<BroadcastReturn<SignedTransaction>>;
+    send: (to: string, amount: number, options?: AddressOptions) => Promise<BroadcastReturn<SignedTransaction>>;
+    sendTrx: (to: string, amount: number, options?: AddressOptions) => Promise<BroadcastReturn<SignedTransaction>>;
+    broadcast: <T extends SignedTransaction>(signedTransaction: T) => Promise<BroadcastReturn<T>>;
+    broadcastHex: (signedHexTransaction: string) => Promise<BroadcastHexReturn | {
+        transaction: Transaction;
+        hexTransaction: string;
+        result: boolean;
+        txid: string;
+        code: string;
+        message: string;
+    }>;
+    signTransaction: <T extends SignedTransaction | Transaction | string>(transaction: T, privateKey?: string | false, useTronHeader?: boolean, multisig?: boolean) => Promise<SignedStringOrSignedTransaction<T>>;
+    constructor(tronWeb: TronWeb);
+    _parseToken(token: any): Token;
+    getCurrentBlock(): Promise<Block>;
+    getConfirmedCurrentBlock(): Promise<Block>;
+    getBlock(block?: 'earliest' | 'latest' | number | string | false): Promise<Block>;
+    getBlockByHash(blockHash: string): Promise<Block>;
+    getBlockByNumber(blockID: number): Promise<Block>;
+    getBlockTransactionCount(block?: 'earliest' | 'latest' | number | string | false): Promise<number>;
+    getTransactionFromBlock(block: ("earliest" | "latest" | number | string | false) | undefined, index: number): Promise<Transaction>;
+    getTransactionsFromBlock(block?: 'earliest' | 'latest' | number | string | false): Promise<Transaction[]>;
+    getTransaction(transactionID: string): Promise<Transaction>;
+    getConfirmedTransaction(transactionID: string): Promise<Transaction>;
+    getUnconfirmedTransactionInfo(transactionID: string): Promise<TransactionInfo>;
+    getTransactionInfo(transactionID: string): Promise<TransactionInfo>;
+    getTransactionsToAddress(address?: string | false, limit?: number, offset?: number): Promise<Transaction[]>;
+    getTransactionsFromAddress(address?: string | false, limit?: number, offset?: number): Promise<Transaction[]>;
+    getTransactionsRelated(address?: string | false, direction?: string, limit?: number, offset?: number): Promise<Transaction[]>;
+    getAccount(address?: string | false): Promise<Account>;
+    getAccountById(id: string): Promise<Account>;
+    getAccountInfoById(id: string, options: {
+        confirmed: boolean;
+    }): Promise<Account>;
+    getBalance(address?: string | false): Promise<number>;
+    getUnconfirmedAccount(address?: string | false): Promise<Account>;
+    getUnconfirmedAccountById(id: string): Promise<Account>;
+    getUnconfirmedBalance(address?: string | false): Promise<number>;
+    getBandwidth(address?: string | false): Promise<number>;
+    getTokensIssuedByAddress(address?: string | false): Promise<Record<string, Token>>;
+    getTokenFromID(tokenID: string | number): Promise<Token>;
+    listNodes(): Promise<string[]>;
+    getBlockRange(start?: number, end?: number): Promise<Block[]>;
+    listSuperRepresentatives(): Promise<Witness[]>;
+    listTokens(limit?: number, offset?: number): Promise<Token[]>;
+    timeUntilNextVoteCycle(): Promise<number>;
+    getContract(contractAddress: string): Promise<any>;
+    ecRecover(transaction: SignedTransaction): string | string[];
+    static ecRecover(transaction: SignedTransaction): Address | Address[];
+    verifyMessage(message: string, signature: string, address?: string | false, useTronHeader?: boolean): Promise<boolean>;
+    static verifySignature(message: string, address: string, signature: string, useTronHeader?: boolean): boolean;
+    verifyMessageV2(message: string | Uint8Array | Array<number>, signature: string): Promise<string>;
+    static verifyMessageV2(message: string | Uint8Array | Array<number>, signature: string): string;
+    verifyTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>, signature: string, address?: string | false): boolean;
+    static verifyTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>, signature: string, address: string): boolean;
+    sign<T extends SignedTransaction | Transaction | string>(transaction: T, privateKey?: string | false, useTronHeader?: boolean, multisig?: boolean): Promise<SignedStringOrSignedTransaction<T>>;
+    static signString(message: string, privateKey: string, useTronHeader?: boolean): string;
+    /**
+     * sign message v2 for verified header length
+     *
+     * @param {message to be signed, should be Bytes or string} message
+     * @param {privateKey for signature} privateKey
+     * @param {reserved} options
+     */
+    signMessageV2(message: string | Uint8Array | Array<number>, privateKey?: string | false): string;
+    static signMessageV2(message: string | Uint8Array | Array<number>, privateKey: string): string;
+    _signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>, privateKey?: string | false): string;
+    static _signTypedData(domain: TypedDataDomain, types: Record<string, TypedDataField[]>, value: Record<string, any>, privateKey: string): string;
+    multiSign(transaction: Transaction, privateKey?: string | false, permissionId?: number): Promise<SignedTransaction<import("../types/Contract.js").ContractParamter>>;
+    getApprovedList(transaction: Transaction): Promise<{
+        approved_list: string[];
+    }>;
+    getSignWeight(transaction: Transaction, permissionId?: number): Promise<TransactionSignWeight>;
+    sendRawTransaction<T extends SignedTransaction>(signedTransaction: T): Promise<BroadcastReturn<T>>;
+    sendHexTransaction(signedHexTransaction: string): Promise<BroadcastHexReturn | {
+        transaction: Transaction;
+        hexTransaction: string;
+        result: boolean;
+        txid: string;
+        code: string;
+        message: string;
+    }>;
+    sendTransaction(to: string, amount: number, options?: AddressOptions): Promise<BroadcastReturn<SignedTransaction>>;
+    sendToken(to: string, amount: number, tokenID: string | number, options?: AddressOptions): Promise<BroadcastReturn<SignedTransaction>>;
+    /**
+     * Freezes an amount of TRX.
+     * Will give bandwidth OR Energy and TRON Power(voting rights)
+     * to the owner of the frozen tokens.
+     *
+     * @param amount - is the number of frozen trx
+     * @param duration - is the duration in days to be frozen
+     * @param resource - is the type, must be either "ENERGY" or "BANDWIDTH"
+     * @param options
+     */
+    freezeBalance(amount?: number, duration?: number, resource?: Resource, options?: AddressOptions, receiverAddress?: string): Promise<BroadcastReturn<SignedTransaction>>;
+    /**
+     * Unfreeze TRX that has passed the minimum freeze duration.
+     * Unfreezing will remove bandwidth and TRON Power.
+     *
+     * @param resource - is the type, must be either "ENERGY" or "BANDWIDTH"
+     * @param options
+     */
+    unfreezeBalance(resource: Resource | undefined, options: AddressOptions | undefined, receiverAddress: string): Promise<BroadcastReturn<SignedTransaction>>;
+    /**
+     * Modify account name
+     * Note: Username is allowed to edit only once.
+     *
+     * @param privateKey - Account private Key
+     * @param accountName - name of the account
+     *
+     * @return modified Transaction Object
+     */
+    updateAccount(accountName: string, options?: AddressOptions): Promise<BroadcastReturn<SignedTransaction>>;
+    /**
+     * Gets a network modification proposal by ID.
+     */
+    getProposal(proposalID: number): Promise<Proposal>;
+    /**
+     * Lists all network modification proposals.
+     */
+    listProposals(): Promise<Proposal[]>;
+    /**
+     * Lists all parameters available for network modification proposals.
+     */
+    getChainParameters(): Promise<ChainParameter[]>;
+    /**
+     * Get the account resources
+     */
+    getAccountResources(address?: string | false): Promise<AccountResourceMessage>;
+    /**
+     * Query the amount of resources of a specific resourceType delegated by fromAddress to toAddress
+     */
+    getDelegatedResourceV2(fromAddress?: string | false, toAddress?: string | false, options?: {
+        confirmed: boolean;
+    }): Promise<{
+        delegatedResource: {
+            from: string;
+            to: string;
+            frozen_balance_for_bandwidth: number;
+            frozen_balance_for_energy: number;
+            expire_time_for_bandwidth: number;
+            expire_time_for_energy: number;
+        };
+    }>;
+    /**
+     * Query the resource delegation index by an account
+     */
+    getDelegatedResourceAccountIndexV2(address?: string | false, options?: {
+        confirmed: boolean;
+    }): Promise<{
+        account: Address;
+        fromAccounts: Address[];
+        toAccounts: Address[];
+    }>;
+    /**
+     * Query the amount of delegatable resources of the specified resource Type for target address, unit is sun.
+     */
+    getCanDelegatedMaxSize(address?: string | false, resource?: Resource, options?: {
+        confirmed: boolean;
+    }): Promise<{
+        max_size: number;
+    }>;
+    /**
+     * Remaining times of available unstaking API
+     */
+    getAvailableUnfreezeCount(address?: string | false, options?: {
+        confirmed: boolean;
+    }): Promise<{
+        count: number;
+    }>;
+    /**
+     * Query the withdrawable balance at the specified timestamp
+     */
+    getCanWithdrawUnfreezeAmount(address?: string | false, timestamp?: number, options?: {
+        confirmed: boolean;
+    }): Promise<{
+        amount: number;
+    }>;
+    /**
+     * Get the exchange ID.
+     */
+    getExchangeByID(exchangeID: number): Promise<Exchange>;
+    /**
+     * Lists the exchanges
+     */
+    listExchanges(): Promise<Exchange[]>;
+    /**
+     * Lists all network modification proposals.
+     */
+    listExchangesPaginated(limit?: number, offset?: number): Promise<Exchange[]>;
+    /**
+     * Get info about thre node
+     */
+    getNodeInfo(): Promise<{
+        beginSyncNum: number;
+        block: string;
+        solidityBlock: string;
+        currentConnectCount: number;
+        activeConnectCount: number;
+        passiveConnectCount: number;
+        totalFlow: number;
+        peerInfoList: {
+            lastSyncBlock: string;
+            remainNum: number;
+            lastBlockUpdateTime: number;
+            syncFlag: boolean;
+            headBlockTimeWeBothHave: number;
+            needSyncFromPeer: boolean;
+            needSyncFromUs: boolean;
+            host: string;
+            port: number;
+            nodeId: string;
+            connectTime: number;
+            avgLatency: number;
+            syncToFetchSize: number;
+            syncToFetchSizePeekNum: number;
+            syncBlockRequestedSize: number;
+            unFetchSynNum: number;
+            blockInPorcSize: number;
+            headBlockWeBothHave: string;
+            isActive: boolean;
+            score: number;
+            nodeCount: number;
+            inFlow: number;
+            disconnectTimes: number;
+            localDisconnectReason: string;
+            remoteDisconnectReason: string;
+        };
+        configNodeInfo: {
+            codeVersion: string;
+            p2pVersion: string;
+            listenPort: number;
+            discoverEnable: boolean;
+            activeNodeSize: number;
+            passiveNodeSize: number;
+            sendNodeSize: number;
+            maxConnectCount: number;
+            sameIpMaxConnectCount: number;
+            backupListenPort: number;
+            backupMemberSize: number;
+            backupPriority: number;
+            dbVersion: number;
+            minParticipationRate: number;
+            supportConstant: boolean;
+            minTimeRatio: number;
+            maxTimeRatio: number;
+            allowCreationOfContracts: number;
+            allowAdaptiveEnergy: number;
+        };
+        machineInfo: {
+            threadCount: number;
+            deadLockThreadCount: number;
+            cpuCount: number;
+            totalMemory: number;
+            freeMemory: number;
+            cpuRate: number;
+            javaVersion: string;
+            osName: string;
+            jvmTotalMemory: number;
+            jvmFreeMemory: number;
+            processCpuRate: number;
+            memoryDescInfoList: {
+                name: string;
+                initSize: number;
+                useSize: number;
+                maxSize: number;
+                useRate: number;
+            };
+            deadLockThreadInfoList: {
+                name: string;
+                lockName: string;
+                lockOwner: string;
+                state: string;
+                blockTime: number;
+                waitTime: number;
+                stackTrace: string;
+            };
+        };
+        cheatWitnessInfoMap: Map<string, string>;
+    }>;
+    getTokenListByName(tokenID: string | number): Promise<Token | Token[]>;
+    getTokenByID(tokenID: number | string): Promise<Token>;
+    getReward(address: Address, options?: {
+        confirmed?: boolean;
+    }): Promise<number>;
+    getUnconfirmedReward(address: Address, options?: {
+        confirmed?: boolean;
+    }): Promise<number>;
+    getBrokerage(address: Address, options?: {
+        confirmed?: boolean;
+    }): Promise<number>;
+    getUnconfirmedBrokerage(address: Address, options?: {
+        confirmed?: boolean;
+    }): Promise<number>;
+    _getReward(address: string | false | undefined, options: {
+        confirmed?: boolean;
+    }): Promise<number>;
+    private _getBrokerage;
+    getBandwidthPrices(): Promise<string>;
+    getEnergyPrices(): Promise<string>;
+}
+export {};