bot-28/node/node_modules/tronweb/lib/commonjs/utils/transaction.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.txCheck = exports.txCheckWithArgs = exports.txJsonToPbWithArgs = exports.txPbToRawDataHex = exports.txPbToTxID = exports.txJsonToPb = void 0;
const tslib_1 = require("tslib");
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-nocheck
const any_pb_js_1 = tslib_1.__importDefault(require("google-protobuf/google/protobuf/any_pb.js"));
require("../protocol/core/Tron_pb.cjs");
const { Transaction, Permission, Key } = globalThis.TronWebProto;
require("../protocol/core/contract/balance_contract_pb.cjs");
const { TransferContract, FreezeBalanceContract, UnfreezeBalanceContract, WithdrawBalanceContract, FreezeBalanceV2Contract, UnfreezeBalanceV2Contract, CancelAllUnfreezeV2Contract, WithdrawExpireUnfreezeContract, DelegateResourceContract, UnDelegateResourceContract, } = globalThis.TronWebProto;
require("../protocol/core/contract/asset_issue_contract_pb.cjs");
const { TransferAssetContract, ParticipateAssetIssueContract, AssetIssueContract, UpdateAssetContract } = globalThis.TronWebProto;
require("../protocol/core/contract/smart_contract_pb.cjs");
const { TriggerSmartContract, ClearABIContract, UpdateEnergyLimitContract, UpdateSettingContract, CreateSmartContract, SmartContract, } = globalThis.TronWebProto;
require("../protocol/core/contract/common_pb.cjs");
const { ResourceCode } = globalThis.TronWebProto;
require("../protocol/core/contract/witness_contract_pb.cjs");
const { WitnessCreateContract, VoteWitnessContract } = globalThis.TronWebProto;
require("../protocol/core/contract/storage_contract_pb.cjs");
const { UpdateBrokerageContract } = globalThis.TronWebProto;
require("../protocol/core/contract/account_contract_pb.cjs");
const { AccountCreateContract, AccountUpdateContract, SetAccountIdContract, AccountPermissionUpdateContract } = globalThis.TronWebProto;
require("../protocol/core/contract/proposal_contract_pb.cjs");
const { ProposalCreateContract, ProposalDeleteContract, ProposalApproveContract } = globalThis.TronWebProto;
require("../protocol/core/contract/exchange_contract_pb.cjs");
const { ExchangeCreateContract, ExchangeInjectContract, ExchangeWithdrawContract, ExchangeTransactionContract } = globalThis.TronWebProto;
const bytes_js_1 = require("./bytes.js");
const ethersUtils_js_1 = require("./ethersUtils.js");
const tronweb_js_1 = tslib_1.__importDefault(require("../tronweb.js"));
const validations_js_1 = require("./validations.js");
const fromHexString = (hexString) => {
    if (!hexString || hexString.length === 0)
        return new Uint8Array([]);
    return new Uint8Array(tronweb_js_1.default.address
        .toHex(hexString)
        .match(/.{1,2}/g)
        .map((byte) => parseInt(byte, 16)));
};
const stringToUint8Array = (hexString) => {
    if (!hexString || hexString.length === 0)
        return new Uint8Array([]);
    return new Uint8Array(((0, validations_js_1.isHex)(hexString) ? hexString : tronweb_js_1.default.toHex(hexString))
        .replace(/^0x/, '')
        .match(/.{1,2}/g)
        .map((byte) => parseInt(byte, 16)));
};
const flexToUint8Array = (str, visible) => {
    if (!visible)
        return stringToUint8Array(str.replace(/^0x/, ''));
    return stringToUint8Array(tronweb_js_1.default.fromUtf8(str).replace(/^0x/, ''));
};
const sha3 = (string, prefix = true) => {
    return (prefix ? '0x' : '') + (0, ethersUtils_js_1.keccak256)(Buffer.from(string, 'utf-8')).toString().substring(2);
};
const buildCommonTransaction = (message, contractType, typeName, permissionId) => {
    const anyValue = new any_pb_js_1.default.Any();
    anyValue.pack(message.serializeBinary(), 'protocol.' + typeName);
    const contract = new Transaction.Contract();
    contract.setType(contractType);
    contract.setParameter(anyValue);
    if (permissionId) {
        contract.setPermissionId(permissionId);
    }
    const raw = new Transaction.raw();
    raw.addContract(contract);
    const transaction = new Transaction();
    transaction.setRawData(raw);
    return transaction;
};
// wallet/createtransaction for sendTrx
const buildTransferContract = (value, options) => {
    const { to_address, owner_address, amount } = value;
    const transferContract = new TransferContract();
    transferContract.setToAddress(fromHexString(to_address));
    transferContract.setOwnerAddress(fromHexString(owner_address));
    transferContract.setAmount(amount);
    return buildCommonTransaction(transferContract, Transaction.Contract.ContractType.TRANSFERCONTRACT, 'TransferContract', options.Permission_id);
};
// wallet/transferasset for sendToken
const buildTransferAssetContract = (value, options) => {
    const { to_address, owner_address, amount, asset_name } = value;
    const transferContract = new TransferAssetContract();
    transferContract.setToAddress(fromHexString(to_address));
    transferContract.setOwnerAddress(fromHexString(owner_address));
    transferContract.setAssetName(flexToUint8Array(asset_name, options.visible));
    transferContract.setAmount(amount);
    return buildCommonTransaction(transferContract, Transaction.Contract.ContractType.TRANSFERASSETCONTRACT, 'TransferAssetContract', options.Permission_id);
};
// wallet/participateassetissue for purchaseToken
const buildParticipateAssetIssueContract = (value, options) => {
    const pbObj = new ParticipateAssetIssueContract();
    pbObj.setToAddress(fromHexString(value.to_address));
    pbObj.setOwnerAddress(fromHexString(value.owner_address));
    pbObj.setAssetName(flexToUint8Array(value.asset_name, options.visible));
    pbObj.setAmount(value.amount);
    return buildCommonTransaction(pbObj, Transaction.Contract.ContractType.PARTICIPATEASSETISSUECONTRACT, 'ParticipateAssetIssueContract', options.Permission_id);
};
const buildTriggerSmartContract = (value, options) => {
    const triggerSmartContract = new TriggerSmartContract();
    const { owner_address, contract_address, parameter = '', function_selector, call_value, call_token_value, token_id, data, } = value;
    triggerSmartContract.setOwnerAddress(fromHexString(owner_address));
    triggerSmartContract.setContractAddress(fromHexString(contract_address));
    triggerSmartContract.setCallValue(call_value);
    if (data) {
        triggerSmartContract.setData(stringToUint8Array(data));
    }
    else if (function_selector) {
        const contractData = sha3(function_selector).substring(2, 10) + parameter;
        triggerSmartContract.setData(stringToUint8Array(contractData));
    }
    if (token_id) {
        triggerSmartContract.setTokenId(token_id);
    }
    if (call_token_value) {
        triggerSmartContract.setCallTokenValue(call_token_value);
    }
    return buildCommonTransaction(triggerSmartContract, Transaction.Contract.ContractType.TRIGGERSMARTCONTRACT, 'TriggerSmartContract', options.Permission_id);
};
const buildFreezeBalanceContract = (value, options) => {
    const freezeBalanceContract = new FreezeBalanceContract();
    const { owner_address, frozen_balance, frozen_duration, resource, receiver_address } = value;
    freezeBalanceContract.setOwnerAddress(fromHexString(owner_address));
    freezeBalanceContract.setFrozenBalance(frozen_balance);
    freezeBalanceContract.setFrozenDuration(frozen_duration);
    if (resource) {
        freezeBalanceContract.setResource(ResourceCode[resource]);
    }
    if (receiver_address) {
        freezeBalanceContract.setReceiverAddress(fromHexString(receiver_address));
    }
    return buildCommonTransaction(freezeBalanceContract, Transaction.Contract.ContractType.FREEZEBALANCECONTRACT, 'FreezeBalanceContract', options.Permission_id);
};
const buildUnfreezeBalanceContract = (value, options) => {
    const unfreezeBalanceContract = new UnfreezeBalanceContract();
    const { owner_address, resource, receiver_address } = value;
    unfreezeBalanceContract.setOwnerAddress(fromHexString(owner_address));
    if (resource) {
        unfreezeBalanceContract.setResource(ResourceCode[resource]);
    }
    if (receiver_address) {
        unfreezeBalanceContract.setReceiverAddress(fromHexString(receiver_address));
    }
    return buildCommonTransaction(unfreezeBalanceContract, Transaction.Contract.ContractType.UNFREEZEBALANCECONTRACT, 'UnfreezeBalanceContract', options.Permission_id);
};
const buildWithdrawBalanceContract = (value, options) => {
    const withdrawbalanceContract = new WithdrawBalanceContract();
    const { owner_address } = value;
    withdrawbalanceContract.setOwnerAddress(fromHexString(owner_address));
    return buildCommonTransaction(withdrawbalanceContract, Transaction.Contract.ContractType.WITHDRAWBALANCECONTRACT, 'WithdrawBalanceContract', options.Permission_id);
};
const buildFreezeBalanceV2Contract = (value, options) => {
    const freezeBalanceV2Contract = new FreezeBalanceV2Contract();
    const { owner_address, frozen_balance, resource } = value;
    freezeBalanceV2Contract.setOwnerAddress(fromHexString(owner_address));
    freezeBalanceV2Contract.setFrozenBalance(frozen_balance);
    freezeBalanceV2Contract.setResource(ResourceCode[resource]);
    return buildCommonTransaction(freezeBalanceV2Contract, Transaction.Contract.ContractType.FREEZEBALANCEV2CONTRACT, 'FreezeBalanceV2Contract', options.Permission_id);
};
const buildCancelFreezeBalanceV2Contract = (value, options) => {
    const cancelAllUnfreezeV2Contract = new CancelAllUnfreezeV2Contract();
    const { owner_address } = value;
    cancelAllUnfreezeV2Contract.setOwnerAddress(fromHexString(owner_address));
    return buildCommonTransaction(cancelAllUnfreezeV2Contract, Transaction.Contract.ContractType.CANCELALLUNFREEZEV2CONTRACT, 'CancelAllUnfreezeV2Contract', options.Permission_id);
};
const buildUnfreezeBalanceV2Contract = (value, options) => {
    const unfreezeBalanceV2Contract = new UnfreezeBalanceV2Contract();
    const { owner_address, unfreeze_balance, resource } = value;
    unfreezeBalanceV2Contract.setOwnerAddress(fromHexString(owner_address));
    unfreezeBalanceV2Contract.setUnfreezeBalance(unfreeze_balance);
    unfreezeBalanceV2Contract.setResource(ResourceCode[resource]);
    return buildCommonTransaction(unfreezeBalanceV2Contract, Transaction.Contract.ContractType.UNFREEZEBALANCEV2CONTRACT, 'UnfreezeBalanceV2Contract', options.Permission_id);
};
const buildDelegateResourceContract = (value, options) => {
    const delegateResourceContract = new DelegateResourceContract();
    const { owner_address, receiver_address, balance, resource, lock = false, lock_period } = value;
    delegateResourceContract.setOwnerAddress(fromHexString(owner_address));
    delegateResourceContract.setBalance(balance);
    delegateResourceContract.setResource(ResourceCode[resource]);
    delegateResourceContract.setLock(lock);
    delegateResourceContract.setLockPeriod(lock_period);
    delegateResourceContract.setReceiverAddress(fromHexString(receiver_address));
    return buildCommonTransaction(delegateResourceContract, Transaction.Contract.ContractType.DELEGATERESOURCECONTRACT, 'DelegateResourceContract', options.Permission_id);
};
const buildUnDelegateResourceContract = (value, options) => {
    const unDelegateResourceContract = new UnDelegateResourceContract();
    const { owner_address, receiver_address, balance, resource } = value;
    unDelegateResourceContract.setOwnerAddress(fromHexString(owner_address));
    unDelegateResourceContract.setBalance(balance);
    unDelegateResourceContract.setResource(ResourceCode[resource]);
    unDelegateResourceContract.setReceiverAddress(fromHexString(receiver_address));
    return buildCommonTransaction(unDelegateResourceContract, Transaction.Contract.ContractType.UNDELEGATERESOURCECONTRACT, 'UnDelegateResourceContract', options.Permission_id);
};
const buildWithdrawExpireUnfreezeContract = (value, options) => {
    const withdrawExpireUnfreeze = new WithdrawExpireUnfreezeContract();
    const { owner_address } = value;
    withdrawExpireUnfreeze.setOwnerAddress(fromHexString(owner_address));
    return buildCommonTransaction(withdrawExpireUnfreeze, Transaction.Contract.ContractType.WITHDRAWEXPIREUNFREEZECONTRACT, 'WithdrawExpireUnfreezeContract', options.Permission_id);
};
// applyForSR
const buildCreateWitness = (value, options) => {
    const createWitnessContract = new WitnessCreateContract();
    const { owner_address, url } = value;
    createWitnessContract.setOwnerAddress(fromHexString(owner_address));
    createWitnessContract.setUrl(stringToUint8Array(url.replace(/^0x/, '')));
    return buildCommonTransaction(createWitnessContract, Transaction.Contract.ContractType.WITNESSCREATECONTRACT, 'WitnessCreateContract', options.Permission_id);
};
// vote
const buildVoteWitnessAccount = (value, options) => {
    const voteWitnessContract = new VoteWitnessContract();
    const { owner_address, votes } = value;
    voteWitnessContract.setOwnerAddress(fromHexString(owner_address));
    votes.forEach((voteItem) => {
        const vote = new VoteWitnessContract.Vote();
        const { vote_address, vote_count } = voteItem;
        vote.setVoteAddress(fromHexString(vote_address));
        const numberOfVotes = parseInt(vote_count);
        vote.setVoteCount(numberOfVotes);
        voteWitnessContract.addVotes(vote);
    });
    return buildCommonTransaction(voteWitnessContract, Transaction.Contract.ContractType.VOTEWITNESSCONTRACT, 'VoteWitnessContract', options.Permission_id);
};
const buildCreateSmartContract = (value, options) => {
    const params = value?.new_contract
        ? {
            ...{
                owner_address: value.owner_address,
                call_token_value: value.call_token_value,
                token_id: value.token_id,
            },
            ...value.new_contract,
        }
        : value;
    const { owner_address, consume_user_resource_percent, origin_energy_limit, abi, bytecode = '', parameter = '', call_value, call_token_value, token_id, name: contracName, } = params;
    let { origin_address } = params;
    const createSmartContract = new CreateSmartContract();
    createSmartContract.setOwnerAddress(fromHexString(owner_address));
    if (token_id) {
        createSmartContract.setTokenId(token_id);
    }
    if (call_token_value) {
        createSmartContract.setCallTokenValue(call_token_value);
    }
    const smartContractBuilder = new SmartContract();
    if (abi) {
        let abiJson;
        if (typeof abi === 'string') {
            abiJson = JSON.parse(abi);
        }
        else {
            abiJson = abi?.entrys || []; // abi could be an empty object if origin abi is `[]`;
        }
        const abiBuilder = new SmartContract.ABI();
        const buildEntryParam = (data) => {
            const param = new SmartContract.ABI.Entry.Param();
            const { indexed, name, type } = data;
            if (indexed === true) {
                param.setIndexed(true);
            }
            param.setName(name);
            param.setType(type);
            return param;
        };
        const entryBuilders = abiJson.map((entry) => {
            const { anonymous, constant, name, inputs, outputs, type, payable, stateMutability } = entry;
            const entryBuilder = new SmartContract.ABI.Entry();
            entryBuilder.setAnonymous(anonymous);
            entryBuilder.setConstant(constant);
            entryBuilder.setName(name);
            if (inputs) {
                entryBuilder.setInputsList(inputs.map((input) => buildEntryParam(input)));
            }
            if (outputs) {
                entryBuilder.setOutputsList(outputs.map((output) => buildEntryParam(output)));
            }
            if (type) {
                entryBuilder.setType(SmartContract.ABI.Entry.EntryType[type.toUpperCase()]);
            }
            entryBuilder.setPayable(payable);
            if (stateMutability) {
                entryBuilder.setStatemutability(SmartContract.ABI.Entry.StateMutabilityType[stateMutability.toUpperCase()]);
            }
            return entryBuilder;
        });
        abiBuilder.setEntrysList(entryBuilders);
        smartContractBuilder.setAbi(abiBuilder);
    }
    if (call_value) {
        smartContractBuilder.setCallValue(call_value);
    }
    smartContractBuilder.setConsumeUserResourcePercent(consume_user_resource_percent);
    smartContractBuilder.setOriginEnergyLimit(origin_energy_limit);
    if (!origin_address) {
        origin_address = owner_address;
    }
    smartContractBuilder.setOriginAddress(fromHexString(origin_address));
    if (bytecode) {
        const bytecodeParameter = bytecode.replace(/^0x/, '') + parameter.replace(/^0x/, '');
        smartContractBuilder.setBytecode(stringToUint8Array(bytecodeParameter));
    }
    smartContractBuilder.setName(contracName);
    createSmartContract.setNewContract(smartContractBuilder);
    return buildCommonTransaction(createSmartContract, Transaction.Contract.ContractType.CREATESMARTCONTRACT, 'CreateSmartContract', options.Permission_id);
};
const buildClearABIContract = (value, options) => {
    const { contract_address, owner_address } = value;
    const clearABIContract = new ClearABIContract();
    clearABIContract.setOwnerAddress(fromHexString(owner_address));
    clearABIContract.setContractAddress(fromHexString(contract_address));
    return buildCommonTransaction(clearABIContract, Transaction.Contract.ContractType.CLEARABICONTRACT, 'ClearABIContract', options.Permission_id);
};
// updateBrokerage
const buildUpdateBrokerageContract = (value, options) => {
    const { brokerage, owner_address } = value;
    const updateBrokerageContract = new UpdateBrokerageContract();
    updateBrokerageContract.setOwnerAddress(fromHexString(owner_address));
    updateBrokerageContract.setBrokerage(brokerage);
    return buildCommonTransaction(updateBrokerageContract, Transaction.Contract.ContractType.UPDATEBROKERAGECONTRACT, 'UpdateBrokerageContract', options.Permission_id);
};
// createToken
const buildAssetIssueContract = (value, options) => {
    const { owner_address, name, abbr, description, url, total_supply, trx_num, num, start_time, end_time, precision, free_asset_net_limit, public_free_asset_net_limit, public_free_asset_net_usage = 0, public_latest_free_net_time = 0, vote_score = 0, frozen_supply, } = value;
    const assetIssueContract = new AssetIssueContract();
    assetIssueContract.setOwnerAddress(fromHexString(owner_address));
    if (name) {
        assetIssueContract.setName(stringToUint8Array(name.replace(/^0x/, '')));
    }
    if (abbr) {
        assetIssueContract.setAbbr(stringToUint8Array(abbr.replace(/^0x/, '')));
    }
    assetIssueContract.setTotalSupply(total_supply);
    assetIssueContract.setNum(num);
    assetIssueContract.setEndTime(end_time);
    assetIssueContract.setStartTime(start_time);
    assetIssueContract.setTrxNum(trx_num);
    assetIssueContract.setVoteScore(vote_score);
    if (precision) {
        assetIssueContract.setPrecision(precision);
    }
    if (public_latest_free_net_time) {
        assetIssueContract.setPublicLatestFreeNetTime(public_latest_free_net_time);
    }
    if (description) {
        assetIssueContract.setDescription(stringToUint8Array(description.replace(/^0x/, '')));
    }
    if (url) {
        assetIssueContract.setUrl(stringToUint8Array(url.replace(/^0x/, '')));
    }
    assetIssueContract.setPublicFreeAssetNetUsage(public_free_asset_net_usage);
    assetIssueContract.setFreeAssetNetLimit(free_asset_net_limit);
    assetIssueContract.setPublicFreeAssetNetLimit(public_free_asset_net_limit);
    if (frozen_supply) {
        const frozenSupplyContract = new AssetIssueContract.FrozenSupply();
        frozenSupplyContract.setFrozenAmount(frozen_supply.length ? frozen_supply[0].frozen_amount : frozen_supply.frozen_amount);
        frozenSupplyContract.setFrozenDays(frozen_supply.length ? frozen_supply[0].frozen_days : frozen_supply.frozen_days);
        assetIssueContract.addFrozenSupply(frozenSupplyContract);
    }
    return buildCommonTransaction(assetIssueContract, Transaction.Contract.ContractType.ASSETISSUECONTRACT, 'AssetIssueContract', options.Permission_id);
};
//createAccount
const buildAccountCreateContract = (value, options) => {
    const accountCreateContract = new AccountCreateContract();
    const { account_address, owner_address } = value;
    accountCreateContract.setOwnerAddress(fromHexString(owner_address));
    accountCreateContract.setAccountAddress(fromHexString(account_address.replace(/^0x/, '')));
    return buildCommonTransaction(accountCreateContract, Transaction.Contract.ContractType.ACCOUNTCREATECONTRACT, 'AccountCreateContract', options.Permission_id);
};
// updateAccount
const buildAccountUpdateContract = (value, options) => {
    const accountUpdateContract = new AccountUpdateContract();
    const { account_name, owner_address } = value;
    accountUpdateContract.setOwnerAddress(fromHexString(owner_address));
    accountUpdateContract.setAccountName(stringToUint8Array(account_name.replace(/^0x/, '')));
    return buildCommonTransaction(accountUpdateContract, Transaction.Contract.ContractType.ACCOUNTUPDATECONTRACT, 'AccountUpdateContract', options.Permission_id);
};
// setAccountId
const buildSetAccountIdContract = (value, options) => {
    const setAccountIdContract = new SetAccountIdContract();
    const { account_id, owner_address } = value;
    setAccountIdContract.setOwnerAddress(fromHexString(owner_address));
    setAccountIdContract.setAccountId(stringToUint8Array(account_id.replace(/^0x/, '')));
    return buildCommonTransaction(setAccountIdContract, Transaction.Contract.ContractType.SETACCOUNTIDCONTRACT, 'SetAccountIdContract', options.Permission_id);
};
const buildProposalCreateContract = (value, options) => {
    const proposalCreateContract = new ProposalCreateContract();
    const { owner_address, parameters } = value;
    proposalCreateContract.setOwnerAddress(fromHexString(owner_address));
    parameters.forEach((parameter) => {
        proposalCreateContract.getParametersMap().set(parameter.key, parameter.value);
    });
    return buildCommonTransaction(proposalCreateContract, Transaction.Contract.ContractType.PROPOSALCREATECONTRACT, 'ProposalCreateContract', options.Permission_id);
};
const buildProposalDeleteContract = (value, options) => {
    const proposalDeleteContract = new ProposalDeleteContract();
    const { owner_address, proposal_id } = value;
    proposalDeleteContract.setOwnerAddress(fromHexString(owner_address));
    proposalDeleteContract.setProposalId(proposal_id);
    return buildCommonTransaction(proposalDeleteContract, Transaction.Contract.ContractType.PROPOSALDELETECONTRACT, 'ProposalDeleteContract', options.Permission_id);
};
const buildVoteProposalContract = (value, options) => {
    const proposalVoteContract = new ProposalApproveContract();
    const { owner_address, proposal_id, is_add_approval } = value;
    proposalVoteContract.setOwnerAddress(fromHexString(owner_address));
    proposalVoteContract.setProposalId(proposal_id);
    proposalVoteContract.setIsAddApproval(is_add_approval);
    return buildCommonTransaction(proposalVoteContract, Transaction.Contract.ContractType.PROPOSALAPPROVECONTRACT, 'ProposalApproveContract', options.Permission_id);
};
const buildExchangeCreateContract = (value, options) => {
    const exchangeCreateContract = new ExchangeCreateContract();
    const { owner_address, first_token_id, first_token_balance, second_token_id, second_token_balance } = value;
    exchangeCreateContract.setOwnerAddress(fromHexString(owner_address));
    exchangeCreateContract.setFirstTokenId(flexToUint8Array(first_token_id, options.visible));
    exchangeCreateContract.setFirstTokenBalance(first_token_balance);
    exchangeCreateContract.setSecondTokenId(flexToUint8Array(second_token_id, options.visible));
    exchangeCreateContract.setSecondTokenBalance(second_token_balance);
    return buildCommonTransaction(exchangeCreateContract, Transaction.Contract.ContractType.EXCHANGECREATECONTRACT, 'ExchangeCreateContract', options.Permission_id);
};
const buildExchangeInjectContract = (value, options) => {
    const exchangeInjectContract = new ExchangeInjectContract();
    const { owner_address, exchange_id, token_id, quant } = value;
    exchangeInjectContract.setOwnerAddress(fromHexString(owner_address));
    exchangeInjectContract.setExchangeId(exchange_id);
    exchangeInjectContract.setTokenId(flexToUint8Array(token_id, options.visible));
    exchangeInjectContract.setQuant(quant);
    return buildCommonTransaction(exchangeInjectContract, Transaction.Contract.ContractType.EXCHANGEINJECTCONTRACT, 'ExchangeInjectContract', options.Permission_id);
};
const buildExchangeWithdrawContract = (value, options) => {
    const exchangeWithdrawContract = new ExchangeWithdrawContract();
    const { owner_address, exchange_id, token_id, quant } = value;
    exchangeWithdrawContract.setOwnerAddress(fromHexString(owner_address));
    exchangeWithdrawContract.setExchangeId(exchange_id);
    exchangeWithdrawContract.setTokenId(flexToUint8Array(token_id, options.visible));
    exchangeWithdrawContract.setQuant(quant);
    return buildCommonTransaction(exchangeWithdrawContract, Transaction.Contract.ContractType.EXCHANGEWITHDRAWCONTRACT, 'ExchangeWithdrawContract', options.Permission_id);
};
const buildExchangeTransactionContract = (value, options) => {
    const exchangeTransactionContract = new ExchangeTransactionContract();
    const { owner_address, exchange_id, token_id, quant, expected } = value;
    exchangeTransactionContract.setOwnerAddress(fromHexString(owner_address));
    exchangeTransactionContract.setExchangeId(exchange_id);
    exchangeTransactionContract.setTokenId(flexToUint8Array(token_id, options.visible));
    exchangeTransactionContract.setQuant(quant);
    exchangeTransactionContract.setExpected(expected);
    return buildCommonTransaction(exchangeTransactionContract, Transaction.Contract.ContractType.EXCHANGETRANSACTIONCONTRACT, 'ExchangeTransactionContract', options.Permission_id);
};
const buildUpdateSettingContract = (value, options) => {
    const updateSettingContract = new UpdateSettingContract();
    const { owner_address, contract_address, consume_user_resource_percent } = value;
    updateSettingContract.setOwnerAddress(fromHexString(owner_address));
    updateSettingContract.setContractAddress(fromHexString(contract_address));
    updateSettingContract.setConsumeUserResourcePercent(consume_user_resource_percent);
    return buildCommonTransaction(updateSettingContract, Transaction.Contract.ContractType.UPDATESETTINGCONTRACT, 'UpdateSettingContract', options.Permission_id);
};
const buildUpdateEnergyLimitContract = (value, options) => {
    const updateEnergyLimitContract = new UpdateEnergyLimitContract();
    const { owner_address, contract_address, origin_energy_limit } = value;
    updateEnergyLimitContract.setOwnerAddress(fromHexString(owner_address));
    updateEnergyLimitContract.setContractAddress(fromHexString(contract_address));
    updateEnergyLimitContract.setOriginEnergyLimit(origin_energy_limit);
    return buildCommonTransaction(updateEnergyLimitContract, Transaction.Contract.ContractType.UPDATEENERGYLIMITCONTRACT, 'UpdateEnergyLimitContract', options.Permission_id);
};
const buildAccountPermissionUpdateContract = (value, options) => {
    const accountPermissionUpdateContract = new AccountPermissionUpdateContract();
    const { owner_address, owner, witness, actives } = value;
    accountPermissionUpdateContract.setOwnerAddress(fromHexString(owner_address));
    const getType = (type) => {
        // no type when permission_name is owner
        if (isNaN(type))
            return type === 'Active' ? 2 : type === 'Witness' ? 1 : 0;
        return type;
    };
    const buildPermission = (data) => {
        // no type when permission_name is owner
        const permission = new Permission();
        const { type, id, permission_name, threshold, parentId, operations, keys } = data;
        permission.setType(getType(type));
        permission.setId(id);
        permission.setPermissionName(permission_name);
        permission.setThreshold(threshold);
        if (parentId) {
            permission.setParentId(parentId);
        }
        if (operations) {
            permission.setOperations(stringToUint8Array(operations));
        }
        if (keys) {
            permission.setKeysList(keys.map((key) => {
                const keyBuilder = new Key();
                keyBuilder.setAddress(fromHexString(key.address));
                keyBuilder.setWeight(key.weight);
                return keyBuilder;
            }));
        }
        return permission;
    };
    if (owner) {
        accountPermissionUpdateContract.setOwner(buildPermission(owner));
    }
    if (witness) {
        accountPermissionUpdateContract.setWitness(buildPermission(witness));
    }
    if (actives) {
        if (Array.isArray(actives)) {
            accountPermissionUpdateContract.setActivesList(actives.map((active) => buildPermission(active)));
        }
        else {
            accountPermissionUpdateContract.setActivesList([buildPermission(actives)]);
        }
    }
    return buildCommonTransaction(accountPermissionUpdateContract, Transaction.Contract.ContractType.ACCOUNTPERMISSIONUPDATECONTRACT, 'AccountPermissionUpdateContract', options.Permission_id);
};
const buildUpdateAssetContract = (value, options) => {
    const updateAssetContract = new UpdateAssetContract();
    const { owner_address, description, url, new_limit, new_public_limit } = value;
    updateAssetContract.setOwnerAddress(fromHexString(owner_address));
    if (description) {
        updateAssetContract.setDescription(stringToUint8Array(description.replace(/^0x/, '')));
    }
    if (url) {
        updateAssetContract.setUrl(stringToUint8Array(url.replace(/^0x/, '')));
    }
    if (new_limit) {
        updateAssetContract.setNewLimit(new_limit);
    }
    if (new_public_limit) {
        updateAssetContract.setNewPublicLimit(new_public_limit);
    }
    return buildCommonTransaction(updateAssetContract, Transaction.Contract.ContractType.UPDATEASSETCONTRACT, 'UpdateAssetContract', options.Permission_id);
};
const contractJsonToProtobuf = (contract, value, options) => {
    switch (contract.type) {
        case 'TransferContract':
            return buildTransferContract(value, options);
        case 'TransferAssetContract':
            return buildTransferAssetContract(value, options);
        case 'ParticipateAssetIssueContract':
            return buildParticipateAssetIssueContract(value, options);
        case 'TriggerSmartContract':
            return buildTriggerSmartContract(value, options);
        case 'FreezeBalanceContract':
            return buildFreezeBalanceContract(value, options);
        case 'UnfreezeBalanceContract':
            return buildUnfreezeBalanceContract(value, options);
        case 'WithdrawBalanceContract':
            return buildWithdrawBalanceContract(value, options);
        case 'FreezeBalanceV2Contract':
            return buildFreezeBalanceV2Contract(value, options);
        case 'CancelAllUnfreezeV2Contract':
            return buildCancelFreezeBalanceV2Contract(value, options);
        case 'UnfreezeBalanceV2Contract':
            return buildUnfreezeBalanceV2Contract(value, options);
        case 'DelegateResourceContract':
            return buildDelegateResourceContract(value, options);
        case 'UnDelegateResourceContract':
            return buildUnDelegateResourceContract(value, options);
        case 'WithdrawExpireUnfreezeContract':
            return buildWithdrawExpireUnfreezeContract(value, options);
        case 'WitnessCreateContract':
            return buildCreateWitness(value, options);
        case 'VoteWitnessContract':
            return buildVoteWitnessAccount(value, options);
        case 'CreateSmartContract':
            return buildCreateSmartContract(value, options);
        case 'ClearABIContract':
            return buildClearABIContract(value, options);
        case 'UpdateBrokerageContract':
            return buildUpdateBrokerageContract(value, options);
        case 'AssetIssueContract':
            return buildAssetIssueContract(value, options);
        case 'AccountCreateContract':
            return buildAccountCreateContract(value, options);
        case 'AccountUpdateContract':
            return buildAccountUpdateContract(value, options);
        case 'SetAccountIdContract':
            return buildSetAccountIdContract(value, options);
        case 'ProposalCreateContract':
            return buildProposalCreateContract(value, options);
        case 'ProposalDeleteContract':
            return buildProposalDeleteContract(value, options);
        case 'ProposalApproveContract':
            return buildVoteProposalContract(value, options);
        case 'ExchangeCreateContract':
            return buildExchangeCreateContract(value, options);
        case 'ExchangeInjectContract':
            return buildExchangeInjectContract(value, options);
        case 'ExchangeWithdrawContract':
            return buildExchangeWithdrawContract(value, options);
        case 'ExchangeTransactionContract':
            return buildExchangeTransactionContract(value, options);
        case 'UpdateSettingContract':
            return buildUpdateSettingContract(value, options);
        case 'UpdateEnergyLimitContract':
            return buildUpdateEnergyLimitContract(value, options);
        case 'AccountPermissionUpdateContract':
            return buildAccountPermissionUpdateContract(value, options);
        case 'UpdateAssetContract':
            return buildUpdateAssetContract(value, options);
    }
};
const txJsonToPb = (transaction) => {
    const rawData = transaction['raw_data'];
    const contractJson = rawData.contract[0];
    const data = contractJson.parameter.value;
    const options = { Permission_id: contractJson.Permission_id, visible: transaction.visible };
    const transactionObj = contractJsonToProtobuf(contractJson, data, options);
    const rawDataObj = transactionObj.getRawData();
    rawDataObj.setRefBlockBytes(stringToUint8Array(rawData.ref_block_bytes));
    rawDataObj.setRefBlockHash(stringToUint8Array(rawData.ref_block_hash));
    if (rawData.data) {
        rawDataObj.setData(stringToUint8Array(rawData.data));
    }
    if (rawData.fee_limit) {
        rawDataObj.setFeeLimit(rawData.fee_limit);
    }
    if (rawData.expiration) {
        rawDataObj.setExpiration(rawData.expiration);
    }
    if (rawData.timestamp) {
        rawDataObj.setTimestamp(rawData.timestamp);
    }
    transactionObj.setRawData(rawDataObj);
    return transactionObj;
};
exports.txJsonToPb = txJsonToPb;
const txJsonToPbWithArgs = (transaction, args = {}, options = {}) => {
    const rawData = transaction['raw_data'];
    const contractJson = rawData.contract[0];
    const transactionObj = contractJsonToProtobuf(contractJson, args, {
        Permission_id: args?.Permission_id,
    });
    const rawDataObj = transactionObj.getRawData();
    rawDataObj.setRefBlockBytes(stringToUint8Array(rawData.ref_block_bytes));
    rawDataObj.setRefBlockHash(stringToUint8Array(rawData.ref_block_hash));
    // for memo
    if (options.data) {
        rawDataObj.setData(stringToUint8Array(options.data.replace(/^0x/, '')));
    }
    if (options.fee_limit || args.fee_limit) {
        rawDataObj.setFeeLimit(options.fee_limit || args.fee_limit);
    }
    if (rawData.expiration) {
        rawDataObj.setExpiration(rawData.expiration);
    }
    if (rawData.timestamp) {
        rawDataObj.setTimestamp(rawData.timestamp);
    }
    transactionObj.setRawData(rawDataObj);
    return transactionObj;
};
exports.txJsonToPbWithArgs = txJsonToPbWithArgs;
const compareTransaction = (transaction, transactionPb) => {
    const rawDataBytes = transactionPb.getRawData().serializeBinary();
    const rawDataHex = (0, bytes_js_1.byteArray2hexStr)(rawDataBytes);
    const txID = (0, ethersUtils_js_1.sha256)(rawDataBytes);
    return (rawDataHex.toLowerCase() === transaction.raw_data_hex.toLowerCase() &&
        txID.replace(/^0x/, '').toLowerCase() === transaction.txID.replace(/^0x/, '').toLowerCase());
};
const txPbToRawDataHex = (pb) => {
    return (0, bytes_js_1.byteArray2hexStr)(pb.getRawData().serializeBinary());
};
exports.txPbToRawDataHex = txPbToRawDataHex;
const txCheck = (transaction) => {
    const transactionPb = txJsonToPb(transaction);
    return compareTransaction(transaction, transactionPb);
};
exports.txCheck = txCheck;
const txCheckWithArgs = (transaction, args, options) => {
    const transactionPb = txJsonToPbWithArgs(transaction, args, options);
    return compareTransaction(transaction, transactionPb);
};
exports.txCheckWithArgs = txCheckWithArgs;
const txPbToTxID = (transactionPb) => {
    const rawDataBytes = transactionPb.getRawData().serializeBinary();
    const txID = (0, ethersUtils_js_1.sha256)(rawDataBytes);
    return txID;
};
exports.txPbToTxID = txPbToTxID;
//# sourceMappingURL=transaction.js.map