bot-28/node/node_modules/tronweb/lib/esm/utils/deserializeTx.js

// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-nocheck
import '../protocol/core/Tron_pb.cjs';
const { Transaction } = globalThis.TronWebProto;
import '../protocol/core/contract/balance_contract_pb.cjs';
const { TransferContract, WithdrawBalanceContract, WitnessCreateContract, FreezeBalanceV2Contract, UnfreezeBalanceV2Contract, CancelAllUnfreezeV2Contract, WithdrawExpireUnfreezeContract, DelegateResourceContract, UnDelegateResourceContract, } = globalThis.TronWebProto;
import '../protocol/core/contract/asset_issue_contract_pb.cjs';
const { TransferAssetContract, ParticipateAssetIssueContract, AssetIssueContract, UpdateAssetContract } = globalThis.TronWebProto;
import '../protocol/core/contract/smart_contract_pb.cjs';
const { TriggerSmartContract } = globalThis.TronWebProto;
import { byteArray2hexStr } from './bytes.js';
import { hexStr2byteArray } from './code.js';
import { isHex } from './validations.js';
const ContractTypeMap = {
    '0': 'AccountCreateContract',
    '1': 'TransferContract',
    '2': 'TransferAssetContract',
    '4': 'VoteWitnessContract',
    '5': 'WitnessCreateContract',
    '6': 'AssetIssueContract',
    '9': 'ParticipateAssetIssueContract',
    '10': 'AccountUpdateContract',
    '11': 'FreezeBalanceContract',
    '12': 'UnfreezeBalanceContract',
    '13': 'WithdrawBalanceContract',
    '15': 'UpdateAssetContract',
    '16': 'ProposalCreateContract',
    '17': 'ProposalApproveContract',
    '18': 'ProposalDeleteContract',
    '19': 'SetAccountIdContract',
    '30': 'CreateSmartContract',
    '31': 'TriggerSmartContract',
    '33': 'UpdateSettingContract',
    '41': 'ExchangeCreateContract',
    '42': 'ExchangeInjectContract',
    '43': 'ExchangeWithdrawContract',
    '44': 'ExchangeTransactionContract',
    '45': 'UpdateEnergyLimitContract',
    '46': 'AccountPermissionUpdateContract',
    '48': 'ClearABIContract',
    '49': 'UpdateBrokerageContract',
    '54': 'FreezeBalanceV2Contract',
    '55': 'UnfreezeBalanceV2Contract',
    '56': 'WithdrawExpireUnfreezeContract',
    '57': 'DelegateResourceContract',
    '58': 'UnDelegateResourceContract',
    '59': 'CancelAllUnfreezeV2Contract',
};
const getAuthsList = (pb) => {
    const authsList = pb.getAuthsList();
    return authsList.map((authPb) => {
        const permission_name = byteArray2hexStr(authPb.getPermissionName_asU8());
        const accountPb = authPb.getAccount();
        const account = {
            name: byteArray2hexStr(accountPb.getName_asU8()),
            address: byteArray2hexStr(accountPb.getAddress_asU8()),
        };
        return {
            permission_name,
            account,
        };
    });
};
const DCommonData = (type, rawDataHex) => {
    const pb = Transaction.raw.deserializeBinary(hexStr2byteArray(rawDataHex));
    const contract = pb.getContractList()[0];
    const valuePb = contract.getParameter().getValue();
    const contractType = ContractTypeMap[contract.getType()];
    if (type !== contractType) {
        throw new Error(`type ${type} dismatches with rawDataHex type ${contractType}`);
    }
    return [
        {
            contract: [
                {
                    parameter: {
                        value: {},
                        type_url: contract.getParameter().getTypeUrl(),
                    },
                    type,
                    Permission_id: contract.getPermissionId(),
                },
            ],
            data: byteArray2hexStr(pb.getData()),
            fee_limit: pb.getFeeLimit(),
            ref_block_bytes: byteArray2hexStr(pb.getRefBlockBytes_asU8()),
            ref_block_hash: byteArray2hexStr(pb.getRefBlockHash_asU8()),
            expiration: pb.getExpiration(),
            timestamp: pb.getTimestamp(),
            scripts: byteArray2hexStr(pb.getScripts_asU8()),
            auths: getAuthsList(pb),
        },
        valuePb,
    ];
};
const DTriggerSmartContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const triggerSmartContract = TriggerSmartContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(triggerSmartContract.getOwnerAddress_asU8()),
        contract_address: byteArray2hexStr(triggerSmartContract.getContractAddress_asU8()),
        call_value: triggerSmartContract.getCallValue(),
        data: byteArray2hexStr(triggerSmartContract.getData_asU8()),
        call_token_value: triggerSmartContract.getCallTokenValue(),
        token_id: triggerSmartContract.getTokenId(),
    };
    return commonData;
};
const getResourceName = (type) => {
    switch (type) {
        case 0:
            return 'BANDWIDTH';
        case 1:
            return 'ENERGY';
        default:
            return 'BANDWIDTH';
    }
};
const DFreezeBalanceV2Contract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const freezeBalanceV2Contract = FreezeBalanceV2Contract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(freezeBalanceV2Contract.getOwnerAddress_asU8()),
        frozen_balance: freezeBalanceV2Contract.getFrozenBalance(),
        resource: getResourceName(freezeBalanceV2Contract.getResource()),
    };
    return commonData;
};
const DUnfreezeBalanceV2Contract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const unfreezeBalanceV2Contract = UnfreezeBalanceV2Contract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(unfreezeBalanceV2Contract.getOwnerAddress_asU8()),
        unfreeze_balance: unfreezeBalanceV2Contract.getUnfreezeBalance(),
        resource: getResourceName(unfreezeBalanceV2Contract.getResource()),
    };
    return commonData;
};
const DCancelAllUnfreezeV2Contract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const cancelAllUnfreezeV2Contract = CancelAllUnfreezeV2Contract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(cancelAllUnfreezeV2Contract.getOwnerAddress_asU8()),
    };
    return commonData;
};
const DDelegateResourceContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const delegateResourceContract = DelegateResourceContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(delegateResourceContract.getOwnerAddress_asU8()),
        balance: delegateResourceContract.getBalance(),
        lock: delegateResourceContract.getLock(),
        lock_period: delegateResourceContract.getLockPeriod(),
        receiver_address: byteArray2hexStr(delegateResourceContract.getReceiverAddress_asU8()),
        resource: getResourceName(delegateResourceContract.getResource()),
    };
    return commonData;
};
const DUnDelegateResourceContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const undelegateResourceContract = UnDelegateResourceContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(undelegateResourceContract.getOwnerAddress_asU8()),
        balance: undelegateResourceContract.getBalance(),
        receiver_address: byteArray2hexStr(undelegateResourceContract.getReceiverAddress_asU8()),
        resource: getResourceName(undelegateResourceContract.getResource()),
    };
    return commonData;
};
const DWithdrawExpireUnfreezeContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const withdrawExpireUnfreezeContract = WithdrawExpireUnfreezeContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(withdrawExpireUnfreezeContract.getOwnerAddress_asU8()),
    };
    return commonData;
};
const DTransferContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const transferContract = TransferContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(transferContract.getOwnerAddress_asU8()),
        to_address: byteArray2hexStr(transferContract.getToAddress_asU8()),
        amount: transferContract.getAmount(),
    };
    return commonData;
};
const DWithdrawBalanceContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const withdrawBalanceContract = WithdrawBalanceContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(withdrawBalanceContract.getOwnerAddress_asU8()),
    };
    return commonData;
};
const DWitnessCreateContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const witnessCreateContract = WitnessCreateContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(witnessCreateContract.getOwnerAddress_asU8()),
        url: byteArray2hexStr(witnessCreateContract.getUrl_asU8()),
    };
    return commonData;
};
const DTransferAssetContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const transferAssetContract = TransferAssetContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(transferAssetContract.getOwnerAddress_asU8()),
        to_address: byteArray2hexStr(transferAssetContract.getToAddress_asU8()),
        asset_name: byteArray2hexStr(transferAssetContract.getAssetName_asU8()),
        amount: transferAssetContract.getAmount(),
    };
    return commonData;
};
const DParticipateAssetIssueContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const participateAssetIssueContract = ParticipateAssetIssueContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(participateAssetIssueContract.getOwnerAddress_asU8()),
        to_address: byteArray2hexStr(participateAssetIssueContract.getToAddress_asU8()),
        asset_name: byteArray2hexStr(participateAssetIssueContract.getAssetName_asU8()),
        amount: participateAssetIssueContract.getAmount(),
    };
    return commonData;
};
const DAssetIssueContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const assetIssueContract = AssetIssueContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(assetIssueContract.getOwnerAddress_asU8()),
        name: byteArray2hexStr(assetIssueContract.getName_asU8()),
        abbr: byteArray2hexStr(assetIssueContract.getAbbr_asU8()),
        description: byteArray2hexStr(assetIssueContract.getDescription_asU8()),
        url: byteArray2hexStr(assetIssueContract.getUrl_asU8()),
        total_supply: assetIssueContract.getTotalSupply(),
        trx_num: assetIssueContract.getTrxNum(),
        num: assetIssueContract.getNum(),
        start_time: assetIssueContract.getStartTime(),
        end_time: assetIssueContract.getEndTime(),
        frozen_supply: assetIssueContract.getFrozenSupplyList().map((frozenPb) => ({
            frozen_amount: frozenPb.getFrozenAmount(),
            frozen_days: frozenPb.getFrozenDays(),
        })),
        free_asset_net_limit: assetIssueContract.getFreeAssetNetLimit(),
        public_free_asset_net_limit: assetIssueContract.getPublicFreeAssetNetLimit(),
        precision: assetIssueContract.getPrecision(),
        vote_score: assetIssueContract.getVoteScore(),
    };
    return commonData;
};
const DUpdateAssetContract = (type, rawDataHex) => {
    const [commonData, valuePb] = DCommonData(type, rawDataHex);
    const updateAssetContract = UpdateAssetContract.deserializeBinary(valuePb);
    commonData.contract[0].parameter.value = {
        owner_address: byteArray2hexStr(updateAssetContract.getOwnerAddress_asU8()),
        description: byteArray2hexStr(updateAssetContract.getDescription_asU8()),
        url: byteArray2hexStr(updateAssetContract.getUrl_asU8()),
        new_limit: updateAssetContract.getNewLimit(),
        new_public_limit: updateAssetContract.getNewPublicLimit(),
    };
    return commonData;
};
const deserializeTransaction = (type, rawDataHex) => {
    if (!rawDataHex) {
        throw new Error('rawDataHex cannot be empty');
    }
    if (!isHex(rawDataHex)) {
        throw new Error('rawDataHex is not a valid hex string');
    }
    switch (type) {
        case 'TriggerSmartContract':
            return DTriggerSmartContract(type, rawDataHex);
        case 'FreezeBalanceV2Contract':
            return DFreezeBalanceV2Contract(type, rawDataHex);
        case 'UnfreezeBalanceV2Contract':
            return DUnfreezeBalanceV2Contract(type, rawDataHex);
        case 'CancelAllUnfreezeV2Contract':
            return DCancelAllUnfreezeV2Contract(type, rawDataHex);
        case 'DelegateResourceContract':
            return DDelegateResourceContract(type, rawDataHex);
        case 'UnDelegateResourceContract':
            return DUnDelegateResourceContract(type, rawDataHex);
        case 'WithdrawExpireUnfreezeContract':
            return DWithdrawExpireUnfreezeContract(type, rawDataHex);
        case 'TransferContract':
            return DTransferContract(type, rawDataHex);
        case 'WithdrawBalanceContract':
            return DWithdrawBalanceContract(type, rawDataHex);
        case 'WitnessCreateContract':
            return DWitnessCreateContract(type, rawDataHex);
        case 'TransferAssetContract':
            return DTransferAssetContract(type, rawDataHex);
        case 'ParticipateAssetIssueContract':
            return DParticipateAssetIssueContract(type, rawDataHex);
        case 'AssetIssueContract':
            return DAssetIssueContract(type, rawDataHex);
        case 'UpdateAssetContract':
            return DUpdateAssetContract(type, rawDataHex);
        default:
            throw new Error(`trasaction ${type} not supported`);
    }
};
export { deserializeTransaction };
//# sourceMappingURL=deserializeTx.js.map