Tron波场开发

原创 于 2025-01-16 17:46:15 发布
· 999 阅读 · 8 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#Tron #波场 #区块链 #USDT

一、前言

文本源自 微博客 且已获授权,请尊重知识产权。

     近段时间公司接到了以为HK客户的一个项目,该项目主要涉及trx、usdt的相互转账，由于tron官方API都是英文且查阅起来不是很方便，加之相对于日常开发任务，tron涉及到的技术算是比较偏，因此下文记录一些Tron常用操作，方便自己积累、同行阅读。

二、具体实现

2.1 yaml配置

tron:
  transactionFee: 0.01
  tronDomainOnline: false
  address: TC32xxx(系统账号)

  privateKey: ENC(1qjg178(钱包私钥,加密配置))

  apiKey: 72fe3xxx(官网申请的apiKey)

  #usdt智能合约地址
  usdtContract: TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t

  # 查询钱包余额
  trxTransferUrl: https://apilist.tronscanapi.com/api/transfer/trx
  
  ustdTransferUrl: https://api.trongrid.io/v1/accounts/{address}/transactions/trc2

  # 转账详情查询地址
  infoUrl: https://apilist.tronscanapi.com/api/transaction-info?hash=
#  账户余额查询地址
  balanceUrl: https://apilist.tronscanapi.com/api/account/tokens?address=
  # 冻结余额
  freezeBalanceUrl: https://api.trongrid.io/wallet/freezebalancev2

对应的配置实体:


import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.tron.trident.core.ApiWrapper;

import java.math.BigDecimal;

/**
 * FileName: Tron
 * Author:   wxz
 * Date:     2024/12/6 11:26
 * Description: tron配置
 */
@Component
@Getter
@Setter
@ConfigurationProperties(prefix = "tron")
public class TronConfig {

    private String address;

    private String trxTransferUrl;

    private String usdtTransferUrl;

    private String balanceUrl;

    private String infoUrl;

    private String apiKey;

    private String privateKey;

    private String usdtContract;

    private String freezeBalanceUrl;

    private boolean tronDomainOnline;

    private BigDecimal transactionFee;

    @Bean
    public ApiWrapper apiWrapper() {
        if (this.isTronDomainOnline()) {
            return ApiWrapper.ofMainnet(this.getPrivateKey(), this.getApiKey());
        }
        return new ApiWrapper("grpc.trongrid.io:50051", "grpc.trongrid.io:50052", this.getPrivateKey());
    }

    public ApiWrapper apiWrapper(String privateKey) {
        if (this.isTronDomainOnline()) {
            return ApiWrapper.ofMainnet(privateKey, this.getApiKey());
        }
        return new ApiWrapper("grpc.trongrid.io:50051", "grpc.trongrid.io:50052", privateKey);
    }
}

2.2 Tron操作工具类


import cn.hutool.core.util.RandomUtil;
import com.tron.config.TronConfig;
import com.tron.dto.AccountBalance;
import com.tron.dto.AccountBalance.Balance;
import com.tron.dto.FreezeDto;
import com.tron.dto.TransferDto;
import com.tron.entity.AjaxResult;
import com.tron.excetion.UtilException;
import lombok.RequiredArgsConstructor;
import lombok.extern.log4j.Log4j2;
import org.springframework.context.annotation.Configuration;
import org.tron.common.crypto.Sha256Sm3Hash;
import org.tron.common.utils.Base58;
import org.tron.keystore.StringUtils;
import org.tron.keystore.WalletFile;
import org.tron.trident.core.ApiWrapper;
import org.tron.trident.core.contract.Contract;
import org.tron.trident.core.contract.Trc20Contract;
import org.tron.trident.core.exceptions.IllegalException;
import org.tron.trident.core.key.KeyPair;
import org.tron.trident.proto.Chain;
import org.tron.trident.proto.Chain.Transaction;
import org.tron.trident.proto.Response.Account;
import org.tron.trident.proto.Response.AccountResourceMessage;
import org.tron.trident.proto.Response.TransactionExtention;
import org.tron.trident.utils.Convert;
import org.tron.trident.utils.Numeric;
import org.tron.walletserver.WalletApi;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

@Configuration
@Log4j2
@RequiredArgsConstructor
public class TronUtil {
    private final TronConfig config;


    /**
     * 激活账户:  √
     *
     * @param hexAddress
     * @return
     */
    public AjaxResult activate(String hexAddress) {
        TransactionExtention transaction = null;
        ApiWrapper wrapper = config.apiWrapper();
        try {
            transaction = wrapper.createAccount(wrapper.keyPair.toBase58CheckAddress(), hexAddress);
            Transaction signedTxn = wrapper.signTransaction(transaction);
            log.info("账号激活结果:{}", signedTxn.toString());
            String s = wrapper.broadcastTransaction(signedTxn);
            wrapper.close();
            return AjaxResult.success(s);
        }
        catch (IllegalException e) {
            e.printStackTrace();
            log.error("账号激活失败,原因: {}", e.getMessage());
            return AjaxResult.error(e.getMessage());
        }
        finally {
            wrapper.close();
        }
    }

    /**
     * 创建账户 √
     *
     * @return
     */
    public static KeyPair generate() {
        KeyPair keyPair = ApiWrapper.generateAddress();
        log.info("生成账号信息: {}", keyPair.toString());
        return keyPair;
    }

    /**
     * 查询账户 √
     *
     * @param hexAddress
     */
    public Account getAccount(String hexAddress) {
        ApiWrapper wrapper = config.apiWrapper();
        Account account = wrapper.getAccount(hexAddress);
        wrapper.close();
        return account;
    }

    /**
     * 转账; 如果付款账号没有交易所需带宽/能量,会冻结以获取;  如果转账金额就是账户可用余额,会在转账金额里面扣除冻结金额,
     */
    public void transferTrx(TransferDto dto) {

        ApiWrapper wrapper = config.apiWrapper(dto.getPrivateKey());
        try {
            long finalTransferAmount = getFinalTransferAmount(wrapper, dto.getFromAddress(), dto.getAmount());
            TransactionExtention transaction = wrapper.transfer(dto.getFromAddress(), dto.getToAddress(),
                    finalTransferAmount);
            Transaction signedTxn = wrapper.signTransaction(transaction, wrapper.keyPair);
            String ret = wrapper.broadcastTransaction(signedTxn);
            log.info("正在进行转账交易,from :{}  ,to :{}  ,balance:{}  , 广播结果:{}", dto.getFromAddress(), dto.getToAddress(),
                    dto.getAmount(), ret);
        }
        catch (Exception e) {
            e.printStackTrace();
            log.error("转账发生错误,原因:{}", e.getMessage());
        }
        finally {
            wrapper.close();
        }
    }


    /**
     * 获取本次实际能交易的金额
     *
     * @param fromAddress 付款账户
     * @param amount      交易金额
     * @return 实际能交易的金额
     */
    private long getFinalTransferAmount(ApiWrapper wrapper, String fromAddress, long amount) {
        AccountResourceMessage accountResource = wrapper.getAccountResource(fromAddress);

        long netLimit = accountResource.getNetLimit();
        long netUsed = accountResource.getNetUsed();
        long energyLimit = accountResource.getEnergyLimit();
        long energyUsed = accountResource.getEnergyUsed();

        log.info("账号带宽:{}", (netLimit - netUsed));
        log.info("账号能量:{}", (energyLimit - energyUsed));

        if ((netUsed < netLimit) && (energyUsed < energyLimit)) {
            return amount;
        }
        Account account = this.getAccount(fromAddress);

        if (amount > account.getBalance()) {
            throw new UtilException("本次交易金额( " + amount + " )大于账户可用余额 " + account.getBalance() + ",交易失败.");
        }

        //本次交易手续费
        long freezeAmount = calculateDynamicFee(wrapper, fromAddress);

        log.error("账户能量不足以支持本次转账,尝试冻结部分余额.....");

        FreezeDto dto = new FreezeDto();

        dto.setAddress(fromAddress).setBalance(freezeAmount);

        long freeze = 0;
        if ((netUsed - netLimit) <= 0) {
            dto.setResourceCode(0);
            if (!delegateResource(dto)) {
                //资源委派失败,冻结付款账号余额以获取交易资格
                freeze += freezeAmount;
                freezeTrxForResources(wrapper, dto);
            }
        }
        if ((energyUsed - energyLimit) <= 0) {
            dto.setResourceCode(1);
            if (!delegateResource(dto)) {
                freeze += freezeAmount;
                freezeTrxForResources(wrapper, dto);
            }
        }

        long totalConsume = freeze + amount;
        //账户余额小于本次交易总费用时,返回实际可交易金额
        if (totalConsume > account.getBalance()) {
            return account.getBalance() - freeze;
        }
        return amount;
    }

    /**
     * 资源委派
     */
    private boolean delegateResource(FreezeDto dto) {
        try {
            WalletFile walletFile =
                    WalletApi.CreateWalletFile(Numeric.hexStringToByteArray(RandomUtil.randomString(18)),
                            Numeric.hexStringToByteArray(config.getPrivateKey()));
            WalletApi api = new WalletApi(walletFile);
            return api.delegateResource(api.getAddress(), dto.getBalance(), dto.getResourceCode(),
                    decode58Check(dto.getAddress()), false, 0);
        }
        catch (Exception e) {
            log.error("资源委派失败,原因:{}", e.getMessage());
            return false;
        }
    }

    /**
     * 动态调整矿工费率
     */
    private long calculateDynamicFee(ApiWrapper wrapper, String fromAddress) {
        // 获取账户资源信息
        AccountResourceMessage accountResource = wrapper.getAccountResource(fromAddress);

        long netLimit = accountResource.getNetLimit();
        long netUsed = accountResource.getNetUsed();
        long energyLimit = accountResource.getEnergyLimit();
        long energyUsed = accountResource.getEnergyUsed();

        // 根据资源使用情况动态调整费用
        // 网络较拥堵时增加费用
        if ((netUsed >= netLimit * 0.8) || (energyUsed >= energyLimit * 0.8)) {
            return Convert.toSun("2", Convert.Unit.TRX).longValue();
        }
        return Convert.toSun("1", Convert.Unit.TRX).longValue();

    }

    /**
     * 冻结trx以获取带宽和能量
     *
     * @return
     */
    public void freezeTrxForResources(ApiWrapper wrapper, FreezeDto dto) {

        String pass = RandomUtil.randomString(18);

        byte[] passwd = StringUtils.char2Byte(pass.toCharArray());
        try {
            WalletFile walletFile = WalletApi.CreateWalletFile(passwd,
                    Numeric.hexStringToByteArray(wrapper.keyPair.toPrivateKey()));
            WalletApi api = new WalletApi(walletFile);

            FreezeUtil freezeUtil = new FreezeUtil();

            boolean b = freezeUtil.freezeBalanceV2(api.getAddress(), dto.getBalance(), dto.getResourceCode(),
                    walletFile, pass);
            if (!b) {
                throw new com.tron.util.UtilException("冻结资金失败,无法操作");
            }
        }
        catch (Exception e) {
            log.error("冻结资金出现问题,原因: {}, 金额:{}", e.getMessage(), dto.getBalance());
            throw new com.tron.util.UtilException("冻结资金失败,无法操作");
        }
    }

    public static byte[] decode58Check(String input) {
        byte[] decodeCheck = Base58.decode(input);
        if (decodeCheck.length <= 4) {
            return null;
        }
        byte[] decodeData = new byte[decodeCheck.length - 4];
        System.arraycopy(decodeCheck, 0, decodeData, 0, decodeData.length);
        byte[] hash0 = Sha256Sm3Hash.hash(decodeData);
        byte[] hash1 = Sha256Sm3Hash.hash(hash0);
        return hash1[0] == decodeCheck[decodeData.length] && hash1[1] == decodeCheck[decodeData.length + 1] && hash1[2] == decodeCheck[decodeData.length + 2] && hash1[3] == decodeCheck[decodeData.length + 3] ? decodeData : null;

    }

    /**
     * 转USDT
     *
     * @param dto
     */
    public void transferUSDT(TransferDto dto) {

        ApiWrapper wrapper = config.apiWrapper(dto.getPrivateKey());

        Contract contract = this.getUsdtContract();

        Trc20Contract token = new Trc20Contract(contract, wrapper.keyPair.toBase58CheckAddress(), wrapper);

        log.error(token);

        long finalTransferAmount = getFinalTransferAmount(wrapper, dto.getFromAddress(), dto.getAmount());

        String transferStr = token.transfer(dto.getToAddress(), finalTransferAmount, 1, "memo", 1);
        log.info(transferStr);

        wrapper.close();
     
    }

    /**
     * 获取ustd转账合约
     */
    public Contract getUsdtContract() {
        ApiWrapper wrapper = config.apiWrapper();
        Contract contract = wrapper.getContract(config.getUsdtContract());
        wrapper.close();
        return contract;
    }


    /**
     * 查询交易状态
     *
     * @param txid
     */
    public String getTransactionStatusById(String txid) throws IllegalException {
        ApiWrapper client = config.apiWrapper();
        Chain.Transaction getTransaction = client.getTransactionById(txid);
        client.close();
        return getTransaction.getRet(0).getContractRet().name();
    }



    /**
     * 获取USTD余额
     *
     * @return 账户余额
     */
    public AccountBalance getBalance(String address) {
        AccountBalance accountBalance = new AccountBalance(address);
        List<Balance> list = new ArrayList<>();
        Account account = this.getAccount(address);

        list.add(new Balance("trx", account.getBalance()));

        ApiWrapper wrapper = config.apiWrapper();
        Trc20Contract token = new Trc20Contract(this.getUsdtContract(), address, wrapper);
        wrapper.close();

        BigInteger bigInteger = token.balanceOf(address);

        list.add(new Balance("usdt", bigInteger.longValue()));

        accountBalance.setBalance(list);
        return accountBalance;
    }
}

2.3 Tron操作工具类


import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import lombok.extern.log4j.Log4j2;
import org.tron.api.GrpcAPI.Return;
import org.tron.api.GrpcAPI.TransactionExtention;
import org.tron.api.GrpcAPI.TransactionSignWeight;
import org.tron.api.GrpcAPI.TransactionSignWeight.Result.response_code;
import org.tron.common.crypto.ECKey;
import org.tron.common.crypto.Hash;
import org.tron.common.crypto.Sha256Sm3Hash;
import org.tron.common.utils.TransactionUtils;
import org.tron.common.utils.Utils;
import org.tron.core.exception.CancelException;
import org.tron.core.exception.CipherException;
import org.tron.keystore.StringUtils;
import org.tron.keystore.Wallet;
import org.tron.keystore.WalletFile;
import org.tron.protos.Protocol.Transaction;
import org.tron.protos.Protocol.Transaction.Contract.ContractType;
import org.tron.protos.contract.BalanceContract.FreezeBalanceV2Contract;
import org.tron.protos.contract.BalanceContract.TransferContract;
import org.tron.protos.contract.SmartContractOuterClass.CreateSmartContract;
import org.tron.walletserver.GrpcClient;

import java.io.IOException;
import java.util.Objects;

import static com.tron.util.TronUtil.decode58Check;
import static org.tron.walletserver.WalletApi.*;

/**
 * FileName: FreezeUtil
 * Author:   wxz
 * Date:     2024/12/18 17:28
 * Description:
 */
@Log4j2
public class FreezeUtil {

    private static final GrpcClient rpcCli = init();

    private static FreezeBalanceV2Contract createFreezeBalanceContractV2(byte[] address, long frozen_balance,
                                                                         int resourceCode) {
        org.tron.protos.contract.BalanceContract.FreezeBalanceV2Contract.Builder builder =
                FreezeBalanceV2Contract.newBuilder();
        ByteString byteAddress = ByteString.copyFrom(address);
        builder.setOwnerAddress(byteAddress).setFrozenBalance(frozen_balance).setResourceValue(resourceCode);
        return builder.build();
    }

    /**
     * 冻结
     *
     * @param ownerAddress
     * @param frozen_balance
     * @param resourceCode
     * @param walletFile
     * @param password
     * @return
     * @throws IOException
     * @throws CancelException
     */
    public boolean freezeBalanceV2(byte[] ownerAddress, long frozen_balance, int resourceCode, WalletFile walletFile,
                                   String password) throws IOException, CancelException {
        FreezeBalanceV2Contract contract = createFreezeBalanceContractV2(ownerAddress, frozen_balance, resourceCode);
        TransactionExtention transactionExtention = rpcCli.createTransaction2(contract);
        return this.processTransactionExtention(transactionExtention, walletFile, password.toCharArray());
    }

    private boolean processTransactionExtention(TransactionExtention transactionExtention, WalletFile walletFile,
                                                char[] password) throws IOException, CancelException {
        if (transactionExtention == null) {
            return false;
        }
        Return ret = transactionExtention.getResult();
        if (!ret.getResult()) {
            log.error("Code = " + ret.getCode());
            log.error("Message = " + ret.getMessage().toStringUtf8());
            return false;
        }
        Transaction transaction = transactionExtention.getTransaction();
        if (transaction.getRawData().getContractCount() == 0) {
            log.error("Transaction is empty");
            return false;
        }
        if (transaction.getRawData().getContract(0).getType() == ContractType.ShieldedTransferContract) {
            return false;
        }

        transaction = this.signTransaction(transaction, walletFile, password);
        this.showTransactionAfterSign(transaction);
        return rpcCli.broadcastTransaction(transaction);

    }

    private void showTransactionAfterSign(Transaction transaction) throws InvalidProtocolBufferException {
        if (transaction.getRawData().getContract(0).getType() == ContractType.CreateSmartContract) {
            CreateSmartContract createSmartContract = (CreateSmartContract) transaction.getRawData()
                    .getContract(0)
                    .getParameter()
                    .unpack(CreateSmartContract.class);
        }

    }

    private byte[] generateContractAddress(byte[] ownerAddress, Transaction trx) {
        byte[] txRawDataHash = Sha256Sm3Hash.of(trx.getRawData().toByteArray()).getBytes();
        byte[] combined = new byte[txRawDataHash.length + ownerAddress.length];
        System.arraycopy(txRawDataHash, 0, combined, 0, txRawDataHash.length);
        System.arraycopy(ownerAddress, 0, combined, txRawDataHash.length, ownerAddress.length);
        return Hash.sha3omit12(combined);
    }

    private Transaction signTransaction(Transaction transaction, WalletFile walletFile, char[] password) throws IOException, CancelException {
        if (transaction.getRawData().getTimestamp() == 0L) {
            transaction = TransactionUtils.setTimestamp(transaction);
        }

        transaction = TransactionUtils.setExpirationTime(transaction);

        try {
            byte[] passwd = StringUtils.char2Byte(password);

            transaction = TransactionUtils.sign(transaction, this.getEcKey(walletFile, passwd));

            TransactionSignWeight weight = getTransactionSignWeight(transaction);
            if (weight.getResult().getCode() == response_code.ENOUGH_PERMISSION) {
                return transaction;
            }

            if (weight.getResult().getCode() != response_code.NOT_ENOUGH_PERMISSION) {
                throw new CancelException(weight.getResult().getMessage());
            }

            System.out.println("Current signWeight is:");
            System.out.println(Utils.printTransactionSignWeight(weight));
            System.out.println("Please confirm if continue add signature enter y or Y, else any other");
        }
        catch (Exception e) {

        }

        this.showTransactionAfterSign(transaction);
        throw new CancelException("User cancelled");
    }

    private ECKey getEcKey(WalletFile walletFile, byte[] password) throws CipherException {
        return Wallet.decrypt(password, walletFile);
    }

    /**
     * 转账
     *
     * @param ownerAddress
     * @param to
     * @param amount
     * @param walletFile
     * @param password
     * @return
     * @throws IOException
     * @throws CancelException
     */
    public boolean sendCoin(byte[] ownerAddress, String to, long amount, WalletFile walletFile, String password) throws IOException, CancelException {
        TransferContract contract = createTransferContract(Objects.requireNonNull(decode58Check(to)), ownerAddress,
                amount);
        TransactionExtention transactionExtention = rpcCli.createTransaction2(contract);
        return this.processTransactionExtention(transactionExtention, walletFile, password.toCharArray());
    }

}

涉及到的DTO:


import lombok.Data;
import lombok.experimental.Accessors;

/**
 * FileName: TransferDto
 * Author:   wxz
 * Date:     2024/12/13 17:28
 * Description:
 */
@Data
@Accessors(chain = true)
public class TransferDto {
    private String fromAddress;
    private String toAddress;
    /**
     * 转账金额,单位为sun(1/1000000trx)
     */
    private long amount;
    private String privateKey;
}

@Data
@Accessors(chain = true)
public class FreezeDto {

    /**
     * 账户地址
     */
    @JsonProperty("owner_address")
    private String address;

    /**
     * 冻结余额
     */
    @JsonProperty("frozen_balance")
    private long balance;

    private final boolean visible = true;

    public void setResourceCode(int resourceCode) {
        if (resourceCode>1 || resourceCode<0){
            throw new UtilException("换取的资源类型不正确");
        }
        this.resourceCode = resourceCode;
    }

    /**
     * 冻结资源换取的资源类型:  BANDWIDTH(0)、ENERGY(1)  ; 默认为:BANDWIDTH
     */
    private int resourceCode;
}


import cn.hutool.core.util.StrUtil;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.ArrayList;
import java.util.List;

/**
 * FileName: AccountBalance
 * Author:   wxz
 * Date:     2024/12/16 14:38
 * Description: 账户余额
 */
@Data
public class AccountBalance {

    private String address;

    private List<Balance> balance = new ArrayList<>();

    public AccountBalance(String address) {
        this.address = address;
    }

    @Data
    @NoArgsConstructor
    public static class Balance {
        /**
         * 余额类型" trx/ustd
         */
        private String tokenAbbr;

        private long balance;

        public Balance(String tokenAbbr, long balance) {
            this.tokenAbbr = tokenAbbr;
            this.balance = balance;
        }
    }

    public long getBalanceByAbbr(String abbr) {
        if (StrUtil.isEmpty(abbr) || this.balance == null || this.balance.size() <= 0) return 0;

        return this.balance.stream()
                .filter(b -> abbr.equalsIgnoreCase(b.getTokenAbbr()))
                .findFirst()
                .map(Balance::getBalance)
                .orElse(0L);
    }

}

三、总结

     上述util中,FreezeUtil是经过我自己拆包、封装的tron提供的控制台工具而来，该工具主要提供账户资金冻结功能，专门拆包、封装这个工具的原因是tron官方提供的API已经升级了，不再支持资金冻结操作，可是又没有找到官方提供的新API，索性就自己拆包了一个控制台操作的接口，重新封装成一个util。

三、涉及到的资源

     上文中涉及到的资源已提供，连接如下：点击下载

官方API:
https://developers.tron.network/reference/background

波场 API Key 使用详解
J_Lee
04-19 2338
文章目录一、什么是tron的API Key？二、请求速率限制2.1 如何判断是否受到速率限制？2.2 如果速率受限怎么办？2.3 限制请求的因素三、使用Trongrid的API Key3.1 创建TronGrid API Key3.2 使用Trongrid的API Key3.3 申领Trongrid 50万请求量 一、什么是tron的API Key？ TronGrid提供TRON网络所有的全节点HTTP API和扩展 API，为了保证请求资源的合理分配，所有的请求API都需要带参数API Key，没有API
波场(Tron)开发demo - go 语言 GRPC版
太阳上的雨天
04-08 1335
【代码】波场(Tron)开发demo - go 语言 GRPC版。
Java实现Tron（波场）区块链的开发实践（二）交易监控与转账
热门推荐
大猩猩的专栏
03-06 1万+
上一节我们具体讲到Java实现Tron波场链的开发部署：通过trident源码编译组件，使用RPC的方式链接Tron波场链，并进行了代码实现，还有如何创建离线钱包。-- 交易监控说白话就是在链接波场链的同时，监控波场链上的交易信息，再把这些交易信息检索和反编码，获取到真实TRX和TRC20所需交易。之所以交易监控放在最后，是因为本人在交易监控上做了很多很多的尝试，最后找到了JAVA实现自认为是最好的实例。-- 不变的是，监控一定以及肯定的是将监控到最后一个块的交易，也就是链上最后一笔交易。
Java实现Tron（波场）区块链的开发实践（一）环境搭建及简单实现
大猩猩的专栏
03-05 6291
最近在开发区块链相关项目时，因本人一直使用JAVA做开发语言，但是区块链开发对JAVA语言相对来说不是很友好。在开发过程中遇到很多的问题，甚至通过百度、Google都无法解决，官方文档大部分篇幅在介绍接口相关信息，对Java实现不多。将组件原代码clone到本地，确认本地已经安装配置好Gradle 6.9.4，进行打包并将打好的组件包，置入项目工程内。可是为了赚点钱，也是硬着头皮，经过重重问题和反复摸索，终于搞定了Torn区块链相关需求的开发。申明：本实践经过自己实现，App产品已上线应用，可放心食用。
Java实现Tron（波场）区块链的开发实践（三）波场链水龙头、WEB3测试实战
大猩猩的专栏
03-07 3506
首先我们需要一个钱包地址，我们不需要钱包进行创建，直接可以通过第一节的离线创建地址代码运行获取，为了更好的测试，我们直接生成两个地址。这一节我们通过部署和开发好的代码，针对测试链进行自测开发，准备测试环境。TronLink为浏览器插件，插件安装成功后，通过私钥导入钱包地址。上一节我们具体讲到Java实现Tron波场链的逻辑代码实现。运行结果会得到钱包地址、私钥、公钥信息；3. 波场链水龙头（官网测试平台发币平台）（🪜）2. 安装区块链钱包（TronLink）
波场 TronGrid API Key 使用详解
最新发布
J_Lee
05-02 6012
波场 TronGrid API Key 使用详解
Java实现Tron（波场）测试DEMO
03-21
在本文中，我们将深入探讨如何使用Java来实现Tron（波场）的测试DEMO，同时结合Spring Boot框架和Gradle构建系统。Tron是一个基于区块链技术的去中心化平台，旨在提供高效、去中心化的数字娱乐内容服务。在开发过程...
tron(波场）trc20离线签名广播交易(Java版本)
浊酒忘今生
01-21 5579
前言 由于在项目中需要，我们又为了节省服务器资源，决定不同步节点数据。也就说说，很多的一些API，我们是不能直接用的了，最直接的有创建地址、签名交易等等 相关API修改 地址生成 TronUtils.java /** * 离线创建地址 * * @return */ public static Map<String, String> createAddress() { ECKey eCkey = new ECKey(random); String privateKey
tron-ddd-cqrs:波场
06-13
《波场tron-ddd-cqrs：基于Spring AOP与AspectJ的领域驱动设计与命令查询职责分离实践》 在IT行业中，领域驱动设计（Domain-Driven Design, DDD）和命令查询职责分离（Command Query Responsibility Segregation, ...
Tron
10-28
TrueType是一种由Apple和Microsoft共同开发的字体格式，广泛应用于各种操作系统中。TRON.TTF文件包含了Tron字体的全部字符集，用户可以通过安装这个文件，在自己的计算机上使用Tron字体进行文本编辑、排版或者设计...
USDT_USDT授权管理USDT合约划扣.zip
04-18
推荐环境：Apache / PHP7.4 / MySQL 5.6 / 宝塔 1. 解压到对应网站目录 2. PHP版本选择7.4 3. 修改数据库连接密码 /config/database.php 4. 添加SSL 5. 网址运行目录 public 5. 后台地址 域名/imadmin 默认用户名：admin 密码admin 关于授权地址的解释： 扫码的用户为A 你自己的地址是B 接收转账的地址为C A扫码之后相当于授权（允许）B操作他账户里的USDT，此时矿工费需要由A来出 B拿到授权后可以转A账户里的USDT至任意地址，最好不要转到B。 B可以将A账户里的USDT转到C，C账户里不需要有矿工费。 （在TRON波场中，C账户至少要有0.1trx保证地址可用） 在转账时，确保每次矿工费不小于6trx（波场）/ 0.001 eth（以太坊）
java-tron：Tron白皮书的Java实现
02-28
java-tron Java实现 ••••• 什么是TRON？ TRON是一个致力于为真正的去中心化Internet构建基础设施的项目。 Tron协议是世界上最大的基于区块链的操作系统之一，提供可扩展的，高可用性和高吞吐量的支持，这些支持是TRON生态系统中所有分散式应用程序的基础。 Tron虚拟机（TVM）允许任何人通过智能合约为自己或社区开发去中心化应用程序（DAPP），从而使去中心化众筹和代币发行比以往任何时候都容易。 TRON可实现大规模开发和参与。 每秒超过2000个事务（TPS），高并发，低延迟和海量数据传输。 它是构建分散娱乐应用程序的理想选择。 免费功能和激励系统使开发人员可以为用户创建优质的应用程序体验。 快速开始 本指南将引导用户完成TRON快速入门（v2.0.0）图像设置。 部署 请在克隆项目后再java-tron Run java-tron 部署方式 向
trident-core:核心软件包和系统覆盖文件
05-10
三叉戟核心 核心软件包和系统覆盖文件 文件层次结构 “ void-files”目录包含“ trident-core”软件包将安装的所有文件的1：1映射。 “ void-files”目录直接映射到根文件系统（“ /”）。 示例：安装后，“ void-files / boot / loader.conf.local”变为“ /boot/loader.conf.local” “ void-files / usr / bin / trident-sysinit”实用程序自动运行 “ void-desktop-files”目录包含“ trident-desktop”软件包将安装的文件的1：1映射。 “ xbps”目录包含这些软件包的Void Linux端口模板（尽管可能首先需要重新生成校验和） 重要档案 注意：安装更新时，下面列出的所有配置文件都会自动替换为较新的版本。 如果您希望本地系统更改
TRC20合约调用DEMO
zhang804633234的专栏
11-22 1854
封装好的demo下载地址。
TRON所有网络信息
J_Lee
04-13 7971
文章目录All networks主网Shasta 测试网Nile 测试网Tronex 测试网DAppChain (SUN Network)Cross Chain全节点Solidity 节点DAppChain 测试网 (SUN Network Testnet)Testnet Cross ChainTestnet Full NodesSolidity Notes All networks 主网 🔍浏览器: https://tronscan.org/ https://tronscan.io/ https://w
TRON账户地址激活问题解答
J_Lee
04-28 1287
文章目录一、波场地址离线创建完毕以后，是否需要马上激活？二、TRON地址未激活会有什么影响？三、TRON地址未激活会影响TRC20代币转入吗？四、trc20代币可以激活地址吗？五、激活地址需要多少TRX？六、如何验证地址已激活？七、激活费用如何扣除 可能很多朋友已经了解到tron的地址离线创建完毕以后，需要激活地址才可以，但还是有一些疑问点，以下就是我列举的部分疑问点，我们一起来找寻一下答案： 一、波场地址离线创建完毕以后，是否需要马上激活？ 不需要，任何时候激活地址都是可以的。 二、TRON地址未激活会有
大模型微调方法：冻结方法 Freeze、P-Tuning 系列、LoRA、QLoRA
Debroon
12-13 1万+
在 Prompt Tuning 中，连续提示仅插入到 Transformer 的第一层输入嵌入序列中，而在接下来的Transformer层中，连续提示位置的嵌入是由之前的 Transformer 层计算得到的。在 P-tuning v2 中，作者发现重参数化的改进很小，尤其是对于较小的模型，同时还会影响模型的表现。：传统的预训练模型中，只有最后一层或者少数几个层的参数会被更新，而其他层的参数保持不变。因此，只微调后几层的全连接层参数，可以保留预训练模型的大部分知识，同时通过微调来适应具体任务的特定要求。
（三）Java与波场系列之trx开发java版本（基于尼罗河测试网）
weixin_42582423的博客
06-01 2316
本篇文章主要介绍波场币转账的java开发操作；前面咱们已经有了我们的测试账户，并且账户中已经有了我们的测试币； 为了方便测试，我们需要再申请一个账户，里边不需要获取测试币转入，只是作为我们java代码转账的目标账户；这里不在赘述申请账户的流程，请看上一篇文章； 废话不多说，直接上代码： trx转账java实现目前一共有两种方法： 1.调用官方接口，实现转账，代码如下： controller层： public String easytransferbyprivate(@RequestPara
TRON对接
yqq1997的博客
05-19 8827
参考 官方API文档: https://developers.tron.network/reference C++ https://github.com/aUscCoder/TronWallet TRON资源模型 参考: https://tronprotocol.github.io/documentation-zh/mechanism&algorithm/resource/ 如果是转账, 目标账户不存在，包括普通转账或发行Token转账，转账操作则会创建账户并转账，只会扣除创建账户消
波场API应用实例解析
标题“tron-api-master.zip”指的是一个压缩文件包，这个文件包内含有与区块链相关的波场（Tron）API例子。波场是一个知名的区块链平台，由Justin Sun于2017年创立，其宗旨是通过去中心化的方式改善互联网基础设施，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值