Java Convert.parseHexString方法代码示例

import nxt.util.Convert; //导入方法依赖的package包/类
@Override
JSONStreamAware processRequest(HttpServletRequest req) throws NxtException {

    Account account = ParameterParser.getAccount(req);
    if (account.getPublicKey() == null) {
        return INCORRECT_ACCOUNT;
    }
    String secretPhrase = ParameterParser.getSecretPhrase(req);
    byte[] data = Convert.parseHexString(Convert.nullToEmpty(req.getParameter("data")));
    byte[] nonce = Convert.parseHexString(Convert.nullToEmpty(req.getParameter("nonce")));
    EncryptedData encryptedData = new EncryptedData(data, nonce);
    boolean isText = !"false".equalsIgnoreCase(req.getParameter("decryptedMessageIsText"));
    try {
        byte[] decrypted = account.decryptFrom(encryptedData, secretPhrase);
        JSONObject response = new JSONObject();
        response.put("decryptedMessage", isText ? Convert.toString(decrypted) : Convert.toHexString(decrypted));
        return response;
    } catch (RuntimeException e) {
        Logger.logDebugMessage(e.toString());
        return DECRYPTION_FAILED;
    }
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
static BlockImpl parseBlock(JSONObject blockData) throws NxtException.ValidationException {
	try {
		int version = ((Long)blockData.get("version")).intValue();
        int timestamp = ((Long)blockData.get("timestamp")).intValue();
        Long previousBlock = Convert.parseUnsignedLong((String) blockData.get("previousBlock"));
        long totalAmountNQT = Convert.parseLong(blockData.get("totalAmountNQT"));
        long totalFeeNQT = Convert.parseLong(blockData.get("totalFeeNQT"));
        int payloadLength = ((Long)blockData.get("payloadLength")).intValue();
        byte[] payloadHash = Convert.parseHexString((String) blockData.get("payloadHash"));
        byte[] generatorPublicKey = Convert.parseHexString((String) blockData.get("generatorPublicKey"));
        byte[] generationSignature = Convert.parseHexString((String) blockData.get("generationSignature"));
        byte[] blockSignature = Convert.parseHexString((String) blockData.get("blockSignature"));
        byte[] previousBlockHash = version == 1 ? null : Convert.parseHexString((String) blockData.get("previousBlockHash"));
        Long nonce = Convert.parseUnsignedLong((String)blockData.get("nonce"));
        
        SortedMap<Long, TransactionImpl> blockTransactions = new TreeMap<>();
        JSONArray transactionsData = (JSONArray)blockData.get("transactions");
        for (Object transactionData : transactionsData) {
            TransactionImpl transaction = TransactionImpl.parseTransaction((JSONObject) transactionData);
            if (blockTransactions.put(transaction.getId(), transaction) != null) {
                throw new NxtException.NotValidException("Block contains duplicate transactions: " + transaction.getStringId());
            }
        }
        byte[] blockATs = Convert.parseHexString( (String) blockData.get("blockATs") );
        return new BlockImpl(version, timestamp, previousBlock, totalAmountNQT, totalFeeNQT, payloadLength, payloadHash, generatorPublicKey,
                generationSignature, blockSignature, previousBlockHash, new ArrayList<>(blockTransactions.values()), nonce , blockATs);
	} catch (NxtException.ValidationException|RuntimeException e) {
		Logger.logDebugMessage("Failed to parse block: " + blockData.toJSONString());
		throw e;
	}
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
static EncryptedData getEncryptedGoods(HttpServletRequest req) throws ParameterException {
    String data = Convert.emptyToNull(req.getParameter("goodsData"));
    String nonce = Convert.emptyToNull(req.getParameter("goodsNonce"));
    if (data != null && nonce != null) {
        try {
            return new EncryptedData(Convert.parseHexString(data), Convert.parseHexString(nonce));
        } catch (RuntimeException e) {
            throw new ParameterException(INCORRECT_DGS_ENCRYPTED_GOODS);
        }
    }
    return null;
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
public static Hallmark parseHallmark(String hallmarkString) {

        byte[] hallmarkBytes = Convert.parseHexString(hallmarkString);

        ByteBuffer buffer = ByteBuffer.wrap(hallmarkBytes);
        buffer.order(ByteOrder.LITTLE_ENDIAN);

        byte[] publicKey = new byte[32];
        buffer.get(publicKey);
        int hostLength = buffer.getShort();
        if (hostLength > 300) {
            throw new IllegalArgumentException("Invalid host length");
        }
        byte[] hostBytes = new byte[hostLength];
        buffer.get(hostBytes);
        String host = Convert.toString(hostBytes);
        int weight = buffer.getInt();
        int date = buffer.getInt();
        buffer.get();
        byte[] signature = new byte[64];
        buffer.get(signature);

        byte[] data = new byte[hallmarkBytes.length - 64];
        System.arraycopy(hallmarkBytes, 0, data, 0, data.length);

        boolean isValid = host.length() < 100 && weight > 0 && weight <= Constants.MAX_BALANCE_NXT
                && Crypto.verify(signature, data, publicKey, true);

        return new Hallmark(hallmarkString, publicKey, signature, host, weight, date, isValid);

    }
 

import nxt.util.Convert; //导入方法依赖的package包/类
private AbstractEncryptedMessage(JSONObject attachmentJSON, JSONObject encryptedMessageJSON) {
    super(attachmentJSON);
    byte[] data = Convert.parseHexString((String)encryptedMessageJSON.get("data"));
    byte[] nonce = Convert.parseHexString((String)encryptedMessageJSON.get("nonce"));
    this.encryptedData = new EncryptedData(data, nonce);
    this.isText = Boolean.TRUE.equals(encryptedMessageJSON.get("isText"));
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
DigitalGoodsDelivery(JSONObject attachmentData) {
    super(attachmentData);
    this.purchaseId = Convert.parseUnsignedLong((String)attachmentData.get("purchase"));
    this.goods = new EncryptedData(Convert.parseHexString((String)attachmentData.get("goodsData")),
            Convert.parseHexString((String)attachmentData.get("goodsNonce")));
    this.discountNQT = Convert.parseLong(attachmentData.get("discountNQT"));
    this.goodsIsText = Boolean.TRUE.equals(attachmentData.get("goodsIsText"));
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
Message(JSONObject attachmentData) {
    super(attachmentData);
    String messageString = (String)attachmentData.get("message");
    this.isText = Boolean.TRUE.equals(attachmentData.get("messageIsText"));
    this.message = isText ? Convert.toBytes(messageString) : Convert.parseHexString(messageString);
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
PublicKeyAnnouncement(JSONObject attachmentData) {
    super(attachmentData);
    this.publicKey = Convert.parseHexString((String)attachmentData.get("recipientPublicKey"));
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
public static byte[] getCreationBytes( HttpServletRequest req ) throws ParameterException {
	try {
		return Convert.parseHexString(req.getParameter("creationBytes"));
	} catch (RuntimeException e) {
		throw new ParameterException(INCORRECT_CREATION_BYTES);
	}
	
	
	
}
 

import nxt.util.Convert; //导入方法依赖的package包/类
AutomatedTransactionsCreation(JSONObject attachmentData) throws NxtException.NotValidException {
	super(attachmentData);
	
	this.name = ( String ) attachmentData.get( "name" );
	this.description = ( String ) attachmentData.get( "description" );
	
	this.creationBytes = Convert.parseHexString( (String) attachmentData.get( "creationBytes" ) );
	
}