tronwb 6.0.0

package/src/lib/TransactionBuilder/helper.ts

@@ -0,0 +1,139 @@
+import { TronWeb } from '../../tronweb.js';
+import { Transaction, TransactionWrapper } from '../../types/Transaction.js';
+import { txCheckWithArgs, txJsonToPb, txPbToTxID, txPbToRawDataHex } from '../../utils/transaction.js';
+import { keccak256 } from '../../utils/ethersUtils.js';
+import { BlockWithoutDetail } from '../../types/APIResponse.js';
+import HttpProvider from '../providers/HttpProvider.js';
+import { ContractParamter, ContractType } from '../../types/Contract.js';
+import { TriggerConstantContractOptions } from '../../types/TransactionBuilder.js';
+
+export function fromUtf8(value: string) {
+    return TronWeb.fromUtf8(value).replace(/^0x/, '');
+}
+
+export function deepCopyJson<T = unknown>(json: object): T {
+    return JSON.parse(JSON.stringify(json));
+}
+export function resultManager(transaction: TransactionWrapper, data: unknown, options: TriggerConstantContractOptions) {
+    if (transaction.Error) throw new Error(transaction.Error);
+
+    if (transaction.result && transaction.result.message) {
+        throw new Error(TronWeb.toUtf8(transaction.result.message));
+    }
+    const authResult = txCheckWithArgs(transaction, data, options);
+    if (authResult) {
+        return transaction;
+    }
+    throw new Error('Invalid transaction');
+}
+
+export function resultManagerTriggerSmartContract(
+    transaction: TransactionWrapper,
+    data: unknown,
+    options: TriggerConstantContractOptions
+) {
+    if (transaction.Error) throw new Error(transaction.Error);
+
+    if (transaction.result && transaction.result.message) {
+        throw new Error(TronWeb.toUtf8(transaction.result.message));
+    }
+
+    if (!(options._isConstant || options.estimateEnergy)) {
+        const authResult = txCheckWithArgs(transaction.transaction, data, options);
+        if (authResult) {
+            return transaction;
+        }
+        throw new Error('Invalid transaction');
+    }
+    return transaction;
+}
+
+export function genContractAddress(ownerAddress: string, txID: string) {
+    return (
+        '41' +
+        keccak256(Buffer.from(txID + ownerAddress, 'hex'))
+            .toString()
+            .substring(2)
+            .slice(24)
+    );
+}
+
+export function getHeaderInfo(node: HttpProvider) {
+    return node.request<BlockWithoutDetail>('wallet/getblock', { detail: false }, 'post').then((data) => {
+        return {
+            ref_block_bytes: data.block_header.raw_data.number.toString(16).slice(-4).padStart(4, '0'),
+            ref_block_hash: data.blockID.slice(16, 32),
+            expiration: data.block_header.raw_data.timestamp + 60 * 1000,
+            timestamp: data.block_header.raw_data.timestamp,
+        };
+    });
+}
+
+function checkBlockHeader(options = {} as Partial<Transaction['raw_data']>): boolean {
+    if (
+        typeof options['ref_block_bytes'] === 'undefined' &&
+        typeof options['ref_block_hash'] === 'undefined' &&
+        typeof options['expiration'] === 'undefined' &&
+        typeof options['timestamp'] === 'undefined'
+    ) {
+        return false;
+    }
+    if (typeof options['ref_block_bytes'] !== 'string') {
+        throw new Error('Invalid ref_block_bytes provided.');
+    }
+    if (typeof options['ref_block_hash'] !== 'string') {
+        throw new Error('Invalid ref_block_hash provided.');
+    }
+    if (typeof options['expiration'] !== 'number') {
+        throw new Error('Invalid expiration provided.');
+    }
+    if (typeof options['timestamp'] !== 'number') {
+        throw new Error('Invalid timestamp provided.');
+    }
+    return true;
+}
+
+export async function createTransaction<T extends ContractParamter>(
+    tronWeb: TronWeb,
+    type: ContractType,
+    value: T,
+    Permission_id?: number,
+    options = {} as Partial<Omit<Transaction['raw_data'], 'contract'>>
+): Promise<Transaction<T>> {
+    const tx: Transaction<T> = {
+        visible: false,
+        txID: '',
+        raw_data_hex: '',
+        raw_data: {
+            contract: [
+                {
+                    parameter: {
+                        value,
+                        type_url: `type.googleapis.com/protocol.${type}`,
+                    },
+                    type,
+                },
+            ],
+            ...(checkBlockHeader(options) ? ({} as Transaction['raw_data']) : await getHeaderInfo(tronWeb.fullNode)),
+            ...options,
+        },
+    };
+    if (Permission_id) {
+        tx.raw_data.contract[0].Permission_id = Permission_id;
+    }
+    const pb = txJsonToPb(tx);
+    tx.txID = txPbToTxID(pb).replace(/^0x/, '');
+    tx.raw_data_hex = txPbToRawDataHex(pb).toLowerCase();
+    return tx;
+}
+
+export function getTransactionOptions(options: { blockHeader?: Partial<Transaction['raw_data']> } = {}) {
+    const ret = {} as Partial<Transaction['raw_data']>;
+    if (checkBlockHeader(options.blockHeader)) {
+        ret['ref_block_bytes'] = options.blockHeader!['ref_block_bytes'];
+        ret['ref_block_hash'] = options.blockHeader!['ref_block_hash'];
+        ret['expiration'] = options.blockHeader!['expiration'];
+        ret['timestamp'] = options.blockHeader!['timestamp'];
+    }
+    return ret;
+}

package/src/lib/contract/index.ts

@@ -0,0 +1,151 @@
+import { TronWeb } from '../../tronweb.js';
+import utils from '../../utils/index.js';
+import { Method, AbiFragmentNoErrConstructor } from './method.js';
+import type { ContractAbiInterface } from '../../types/ABI.js';
+import { Address } from '../../types/Trx.js';
+import { CreateSmartContractOptions } from '../../types/TransactionBuilder.js';
+
+
+export class Contract {
+    tronWeb: TronWeb;
+    abi: ContractAbiInterface;
+    address: false | string;
+    eventListener: any;
+    bytecode?: false | string;
+    deployed?: boolean;
+    lastBlock?: false | number;
+    methods: Record<string | number | symbol, (...args: any) => ReturnType<Method['onMethod']>>;
+    methodInstances: Record<string | number | symbol, Method>;
+    props: any[];
+    [key: string | number | symbol]: any;
+
+    constructor(tronWeb: TronWeb, abi: ContractAbiInterface = [], address: Address) {
+        if (!tronWeb || !(tronWeb instanceof TronWeb)) throw new Error('Expected instance of TronWeb');
+
+        this.tronWeb = tronWeb;
+
+        this.address = address;
+        this.abi = abi;
+
+        this.eventListener = false;
+        this.bytecode = false;
+        this.deployed = false;
+        this.lastBlock = false;
+
+        this.methods = {};
+        this.methodInstances = {};
+        this.props = [];
+
+        if (utils.address.isAddress(address)) {
+            this.deployed = true;
+        } else {
+            this.address = false;
+        }
+
+        this.loadAbi(abi);
+    }
+
+    hasProperty(property: number | string | symbol) {
+        // eslint-disable-next-line no-prototype-builtins
+        return this.hasOwnProperty(property) || (this as any).__proto__.hasOwnProperty(property);
+    }
+
+    loadAbi(abi: ContractAbiInterface) {
+        this.abi = abi;
+        this.methods = {};
+
+        this.props.forEach((prop: string) => delete (this as any)[prop]);
+
+        abi.forEach((func) => {
+            // Don't build a method for constructor function. That's handled through contract create.
+            // Don't build a method for error function.
+            if (!func.type || /constructor|error/i.test(func.type)) return;
+
+            const method = new Method(this, func as AbiFragmentNoErrConstructor);
+            const methodCall = method.onMethod.bind(method);
+
+            const { name, functionSelector, signature } = method;
+
+            this.methods[name] = methodCall;
+            this.methods[functionSelector!] = methodCall;
+            this.methods[signature] = methodCall;
+
+            this.methodInstances[name] = method;
+            this.methodInstances[functionSelector!] = method;
+            this.methodInstances[signature] = method;
+
+            if (!this.hasProperty(name)) {
+                (this as any)[name] = methodCall;
+                this.props.push(name);
+            }
+
+            if (!this.hasProperty(functionSelector!)) {
+                (this as any)[functionSelector!] = methodCall;
+                this.props.push(functionSelector);
+            }
+
+            if (!this.hasProperty(signature)) {
+                (this as any)[signature] = methodCall;
+                this.props.push(signature);
+            }
+        });
+    }
+
+    decodeInput(data: string) {
+        const methodName = data.substring(0, 8);
+        const inputData = data.substring(8);
+
+        if (!this.methodInstances[methodName]) throw new Error('Contract method ' + methodName + ' not found');
+
+        const methodInstance = this.methodInstances[methodName];
+
+        return {
+            name: methodInstance.name,
+            params: this.methodInstances[methodName].decodeInput(inputData),
+        };
+    }
+
+    async new(options: CreateSmartContractOptions, privateKey = this.tronWeb.defaultPrivateKey) {
+        const address = this.tronWeb.address.fromPrivateKey(privateKey as string);
+        const transaction = await this.tronWeb.transactionBuilder.createSmartContract(options, address as Address);
+        const signedTransaction = await this.tronWeb.trx.sign(transaction, privateKey);
+        const contract = await this.tronWeb.trx.sendRawTransaction(signedTransaction);
+
+        if (contract.code) {
+            throw {
+                error: contract.code,
+                message: this.tronWeb.toUtf8(contract.message),
+            };
+        }
+
+        await utils.sleep(3000);
+        return this.at(signedTransaction.contract_address);
+    }
+
+    async at(contractAddress: Address) {
+        try {
+            const contract = await this.tronWeb.trx.getContract(contractAddress);
+
+            if (!contract.contract_address) {
+                throw new Error('Unknown error: ' + JSON.stringify(contract, null, 2));
+            }
+
+            this.address = contract.contract_address;
+            this.bytecode = contract.bytecode;
+            this.deployed = true;
+
+            this.loadAbi(contract.abi ? (contract.abi.entrys ? contract.abi.entrys : []) : []);
+
+            return this;
+        } catch (ex: any) {
+            if (ex.toString().includes('does not exist')) {
+                throw new Error('Contract has not been deployed on the network');
+            }
+
+            throw new Error(ex);
+        }
+    }
+}
+
+export type { CallOptions, SendOptions, AbiFragmentNoErrConstructor } from './method.js';
+export { Method } from './method.js';

package/src/lib/contract/method.ts

@@ -0,0 +1,336 @@
+/* eslint-disable no-control-regex */
+import utils from '../../utils/index.js';
+import { encodeParamsV2ByABI, decodeParamsV2ByABI } from '../../utils/abi.js';
+import { TronWeb } from '../../tronweb.js';
+import { Contract } from './index.js';
+import { sha3 } from '../../utils/crypto.js';
+
+export interface CallOptions {
+    feeLimit?: number;
+    callValue?: number;
+    callTokenValue?: number;
+    callTokenId?: number;
+    userFeePercentage?: number;
+    shouldPollResponse?: boolean;
+    from?: string | false;
+    rawParameter?: string;
+    _isConstant?: true;
+}
+
+export interface SendOptions {
+    from?: string | false;
+    feeLimit?: number;
+    callValue?: number;
+    rawParameter?: string;
+    userFeePercentage?: number;
+    shouldPollResponse?: boolean;
+    pollTimes?: number;
+    rawResponse?: boolean;
+    keepTxID?: boolean;
+}
+
+import type {
+    FragmentTypes,
+    StateMutabilityTypes,
+    FunctionFragment,
+    FallbackFragment,
+    ReceiveFragment,
+    EventFragment,
+    AbiInputsType,
+    AbiOutputsType,
+} from '../../types/ABI.js';
+
+export type AbiFragmentNoErrConstructor = FunctionFragment | EventFragment | FallbackFragment | ReceiveFragment;
+
+const getFunctionSelector = (abi: AbiFragmentNoErrConstructor) => {
+    if ('stateMutability' in abi) {
+        (abi.stateMutability as StateMutabilityTypes) = abi.stateMutability ? abi.stateMutability.toLowerCase() : 'nonpayable';
+    }
+    (abi.type as FragmentTypes) = abi.type ? abi.type.toLowerCase() : '';
+    if (abi.type === 'fallback' || abi.type === 'receive') return '0x';
+    const iface = new utils.ethersUtils.Interface([abi]);
+    let obj;
+    if (abi.type === 'event') {
+        obj = iface.getEvent(abi.name);
+    } else {
+        obj = iface.getFunction(abi.name);
+    }
+    if (obj) {
+        return obj.format('sighash');
+    }
+    throw new Error('unknown function');
+};
+
+const decodeOutput = (abi: AbiFragmentNoErrConstructor, output: string) => {
+    return decodeParamsV2ByABI(abi, output);
+};
+
+export class Method {
+    tronWeb: TronWeb;
+    contract: Contract;
+    abi: AbiFragmentNoErrConstructor;
+    name: string;
+    inputs: AbiInputsType;
+    outputs: AbiOutputsType;
+    functionSelector: string | null;
+    signature: string;
+    defaultOptions: {
+        feeLimit: number;
+        callValue: number;
+        userFeePercentage: number;
+        shouldPollResponse: boolean;
+    };
+
+    constructor(contract: Contract, abi: AbiFragmentNoErrConstructor) {
+        this.tronWeb = contract.tronWeb;
+        this.contract = contract;
+
+        this.abi = abi;
+        this.name = abi.name || abi.type;
+
+        this.inputs = abi.inputs || [];
+
+        this.outputs = [];
+        if ('outputs' in abi && abi.outputs) {
+            this.outputs = abi.outputs;
+        }
+
+        this.functionSelector = getFunctionSelector(abi);
+        this.signature = sha3(this.functionSelector, false).slice(0, 8);
+
+        this.defaultOptions = {
+            feeLimit: this.tronWeb.feeLimit,
+            callValue: 0,
+            userFeePercentage: 100,
+            shouldPollResponse: false, // Only used for sign()
+        };
+    }
+
+    decodeInput(data: string) {
+        const abi = JSON.parse(JSON.stringify(this.abi));
+        abi.outputs = abi.inputs;
+        return decodeOutput(abi, '0x' + data);
+    }
+
+    onMethod(...args: any[]) {
+        let rawParameter = '';
+        if (this.abi && !/event/i.test(this.abi.type)) {
+            rawParameter = encodeParamsV2ByABI(this.abi, args);
+        }
+        return {
+            call: async (options: CallOptions = {}) => {
+                options = {
+                    ...options,
+                    rawParameter,
+                };
+
+                return await this._call([], [], options);
+            },
+            send: async (options: SendOptions = {}, privateKey = this.tronWeb.defaultPrivateKey) => {
+                options = {
+                    ...options,
+                    rawParameter,
+                };
+
+                return await this._send([], [], options, privateKey);
+            },
+        };
+    }
+
+    async _call(types: [], args: [], options: CallOptions = {}) {
+        if (types.length !== args.length) {
+            throw new Error('Invalid argument count provided');
+        }
+
+        if (!this.contract.address) {
+            throw new Error('Smart contract is missing address');
+        }
+
+        if (!this.contract.deployed) {
+            throw new Error('Calling smart contracts requires you to load the contract first');
+        }
+        if ('stateMutability' in this.abi) {
+            const { stateMutability } = this.abi;
+
+            if (stateMutability && !['pure', 'view'].includes(stateMutability.toLowerCase())) {
+                throw new Error(`Methods with state mutability "${stateMutability}" must use send()`);
+            }
+        }
+
+        options = {
+            ...this.defaultOptions,
+            from: this.tronWeb.defaultAddress.hex,
+            ...options,
+            _isConstant: true,
+        };
+
+        const parameters = args.map((value, index) => ({
+            type: types[index],
+            value,
+        }));
+
+        const transaction = await this.tronWeb.transactionBuilder.triggerSmartContract(
+            this.contract.address,
+            this.functionSelector!,
+            options,
+            parameters,
+            options.from ? this.tronWeb.address.toHex(options.from) : undefined
+        );
+
+        if (!utils.hasProperty(transaction, 'constant_result')) {
+            throw new Error('Failed to execute');
+        }
+
+        const len = transaction.constant_result![0].length;
+        if (len === 0 || len % 64 === 8) {
+            let msg = 'The call has been reverted or has thrown an error.';
+            if (len !== 0) {
+                msg += ' Error message: ';
+                let msg2 = '';
+                const chunk = transaction.constant_result![0].substring(8);
+                for (let i = 0; i < len - 8; i += 64) {
+                    msg2 += this.tronWeb.toUtf8(chunk.substring(i, i + 64));
+                }
+                msg += msg2
+                    .replace(/(\u0000|\u000b|\f)+/g, ' ')
+                    .replace(/ +/g, ' ')
+                    .replace(/\s+$/g, '');
+            }
+            throw new Error(msg);
+        }
+
+        let output = decodeOutput(this.abi, '0x' + transaction.constant_result![0]);
+
+        if (output.length === 1 && Object.keys(output).length === 1) {
+            output = output[0];
+        }
+        return output;
+    }
+
+    async _send(types: [], args: [], options: SendOptions = {}, privateKey = this.tronWeb.defaultPrivateKey) {
+        if (types.length !== args.length) {
+            throw new Error('Invalid argument count provided');
+        }
+
+        if (!this.contract.address) {
+            throw new Error('Smart contract is missing address');
+        }
+
+        if (!this.contract.deployed) {
+            throw new Error('Calling smart contracts requires you to load the contract first');
+        }
+
+        const { stateMutability } = this.abi as { stateMutability: StateMutabilityTypes };
+
+        if (['pure', 'view'].includes(stateMutability.toLowerCase())) {
+            throw new Error(`Methods with state mutability "${stateMutability}" must use call()`);
+        }
+
+        // If a function isn't payable, dont provide a callValue.
+        if (!['payable'].includes(stateMutability.toLowerCase())) {
+            options.callValue = 0;
+        }
+
+        options = {
+            ...this.defaultOptions,
+            from: this.tronWeb.defaultAddress.hex,
+            ...options,
+        };
+
+        const parameters = args.map((value, index) => ({
+            type: types[index],
+            value,
+        }));
+
+        const address = privateKey ? this.tronWeb.address.fromPrivateKey(privateKey) : this.tronWeb.defaultAddress.base58;
+        const transaction = await this.tronWeb.transactionBuilder.triggerSmartContract(
+            this.contract.address,
+            this.functionSelector!,
+            options,
+            parameters,
+            this.tronWeb.address.toHex(address as string)
+        );
+
+        if (!transaction.result || !transaction.result.result) {
+            throw new Error('Unknown error: ' + JSON.stringify(transaction, null, 2));
+        }
+
+        // If privateKey is false, this won't be signed here. We assume sign functionality will be replaced.
+        const signedTransaction = await this.tronWeb.trx.sign(transaction.transaction, privateKey);
+
+        if (!signedTransaction.signature) {
+            if (!privateKey) {
+                throw new Error('Transaction was not signed properly');
+            }
+
+            throw new Error('Invalid private key provided');
+        }
+
+        const broadcast = await this.tronWeb.trx.sendRawTransaction(signedTransaction);
+
+        if (broadcast.code) {
+            const err = {
+                error: broadcast.code,
+                message: broadcast.code as unknown as string,
+            };
+            if (broadcast.message) err.message = this.tronWeb.toUtf8(broadcast.message);
+            const error = new Error(err.message);
+            (error as any).error = broadcast.code;
+            throw error;
+        }
+
+        if (!options.shouldPollResponse) {
+            return signedTransaction.txID;
+        }
+
+        const checkResult: (index: number) => any = async (index) => {
+            if (index === (options.pollTimes || 20)) {
+                const error: any = new Error('Cannot find result in solidity node');
+                error.error = 'Cannot find result in solidity node';
+                error.transaction = signedTransaction;
+                throw error;
+            }
+
+            const output = await this.tronWeb.trx.getTransactionInfo(signedTransaction.txID);
+
+            if (!Object.keys(output).length) {
+                await new Promise((r) => setTimeout(r, 3000));
+                return checkResult(index + 1);
+            }
+
+            if (output.result && output.result === 'FAILED') {
+                const error: any = new Error(this.tronWeb.toUtf8(output.resMessage));
+                error.error = this.tronWeb.toUtf8(output.resMessage);
+                error.transaction = signedTransaction;
+                error.output = output;
+                throw error;
+            }
+
+            if (!utils.hasProperty(output, 'contractResult')) {
+                const error: any = new Error('Failed to execute: ' + JSON.stringify(output, null, 2));
+                error.error = 'Failed to execute: ' + JSON.stringify(output, null, 2);
+                error.transaction = signedTransaction;
+                error.output = output;
+                throw error;
+            }
+
+            if (options.rawResponse) {
+                return output;
+            }
+
+            let decoded = decodeOutput(this.abi, '0x' + output.contractResult[0]);
+
+            if (decoded.length === 1 && Object.keys(decoded).length === 1) {
+                decoded = decoded[0];
+            }
+
+            if (options.keepTxID) {
+                return [signedTransaction.txID, decoded];
+            }
+
+            return decoded;
+        };
+
+        return checkResult(0);
+    }
+}