Transfer Problem about java-sdk HOT 13 CLOSED

private static final BigDecimal MULTIPLY_FACTOR = BigDecimal.valueOf(1e8);
private static final BigDecimal MAX_NUMBER = new BigDecimal(Long.MAX_VALUE);
private static final okhttp3.MediaType MEDIA_TYPE = okhttp3.MediaType.parse("text/plain; charset=utf-8");


public static RequestBody getTransferPayload(TransferParams params) {
    LogT.e(JSON.toJSONString(params));

    String symbol = params.getSymbol();
    String toAddress = params.getToAddress();
    String fromAddress = params.getFromAddress();
    String amount = params.getAmount();
    byte[] data = params.getOption_data();
    String chainId = params.getChainId();
    String sequence = params.getSequence();
    String memo = params.getMemo();
    long source = params.getOption_source();
    String option_memo = params.getOption_memo();
    String accountNumber = params.getAccountNumber();
    String privateKey = params.getPrivateKey();
    byte[] publicKeyForSign = params.getPublicKeyForSign();

    String buildTransferPayload = "";
    Transfer transfer = new Transfer();
    transfer.setCoin(symbol);
    transfer.setFromAddress(fromAddress);
    transfer.setToAddress(toAddress);
    transfer.setAmount(amount);
    TransferMessage msgBean = createTransferMessage(transfer);

    Log.e("BnbUtils:", "msgBean:" + msgBean.toString());
    try {
        byte[] msg = encodeTransferMessage(msgBean);
        byte[] sign = sign(msgBean, chainId, accountNumber, sequence, option_memo, source, data, privateKey);
        byte[] signature = encodeSignature(sign, publicKeyForSign, accountNumber, sequence);
        byte[] stdTx = encodeStdTx(msg, signature, data, memo, source);
        buildTransferPayload = EncodeUtils.bytesToHex(stdTx);
    } catch (IOException e) {
        e.printStackTrace();
    }
    return RequestBody.create(MEDIA_TYPE, buildTransferPayload);
}


static byte[] sign(BinanceDexTransactionMessage msg, String chainId, String accountNumber, String sequence, String memo, long source, byte[] data, String privateKey) {
    SignData sd = new SignData();
    sd.setChainId(chainId);
    sd.setAccountNumber(accountNumber);
    sd.setSequence(sequence);
    sd.setMsgs(new BinanceDexTransactionMessage[]{msg});
    sd.setMemo(memo);
    sd.setSource(String.valueOf(source));
    if (data != null) {
        sd.setData(data);
    }
    try {
        return Crypto.sign(EncodeUtils.toJsonEncodeBytes(sd), ECKey.fromPrivate(new BigInteger(privateKey, 16)));
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    } catch (JsonProcessingException e) {
        e.printStackTrace();
    }
    return null;
}


static byte[] encodeStdTx(byte[] msg, byte[] signature, byte[] data, String memo, long source) {
    StdTx.Builder stdTxBuilder = StdTx.newBuilder()
            .addMsgs(ByteString.copyFrom(msg))
            .addSignatures(ByteString.copyFrom(signature))
            .setMemo(memo)
            .setSource(source);

    if (data != null) {
        stdTxBuilder = stdTxBuilder.setData(ByteString.copyFrom(data));
    }
    StdTx stdTx = stdTxBuilder.build();
    try {
        return EncodeUtils.aminoWrap(stdTx.toByteArray(), MessageType.StdTx.getTypePrefixBytes(), true);
    } catch (IOException e) {
        e.printStackTrace();
    }
    return null;

}

private static byte[] encodeSignature(byte[] signatureBytes, byte[] publickeyForSign, String accountNumber, String sequence) throws IOException {
    StdSignature stdSignature = StdSignature.newBuilder().setPubKey(ByteString.copyFrom(publickeyForSign))
            .setSignature(ByteString.copyFrom(signatureBytes))
            .setAccountNumber(Long.valueOf(accountNumber))
            .setSequence(Long.valueOf(sequence))
            .build();

    return EncodeUtils.aminoWrap(
            stdSignature.toByteArray(), MessageType.StdSignature.getTypePrefixBytes(), false);
}


private static byte[] encodeTransferMessage(TransferMessage msg)
        throws IOException {
    Send.Builder builder = Send.newBuilder();
    for (InputOutput input : msg.getInputs()) {
        builder.addInputs(toProtoInput(input));
    }
    for (InputOutput output : msg.getOutputs()) {
        builder.addOutputs(toProtoOutput(output));
    }
    Send proto = builder.build();
    return EncodeUtils.aminoWrap(proto.toByteArray(), MessageType.Send.getTypePrefixBytes(), false);
}


private static long doubleToLong(String d) {
    BigDecimal encodeValue = new BigDecimal(d).multiply(MULTIPLY_FACTOR);
    if (encodeValue.compareTo(BigDecimal.ZERO) <= 0) {
        throw new IllegalArgumentException(d + " is less or equal to zero.");
    }
    if (encodeValue.compareTo(MAX_NUMBER) > 0) {
        throw new IllegalArgumentException(d + " is too large.");
    }
    return encodeValue.longValue();

}


private static TransferMessage createTransferMessage(Transfer transfer) {
    Token token = new Token();
    token.setDenom(transfer.getCoin());
    token.setAmount(doubleToLong(transfer.getAmount()));
    List<Token> coins = Collections.singletonList(token);

    InputOutput input = new InputOutput();
    input.setAddress(transfer.getFromAddress());
    input.setCoins(coins);
    InputOutput output = new InputOutput();
    output.setAddress(transfer.getToAddress());
    output.setCoins(coins);

    TransferMessage msgBean = new TransferMessage();
    msgBean.setInputs(Collections.singletonList(input));
    msgBean.setOutputs(Collections.singletonList(output));
    return msgBean;
}

private static Send.Input toProtoInput(InputOutput input) {
    byte[] address = Crypto.decodeAddress(input.getAddress());
    Send.Input.Builder builder =
            Send.Input.newBuilder().setAddress(ByteString.copyFrom(address));

    for (Token coin : input.getCoins()) {
        Send.Token protCoin =
                Send.Token.newBuilder().setAmount(coin.getAmount())
                        .setDenom(coin.getDenom()).build();
        builder.addCoins(protCoin);
    }
    return builder.build();
}

private static Send.Output toProtoOutput(InputOutput output) {
    byte[] address = Crypto.decodeAddress(output.getAddress());
    Send.Output.Builder builder =
            Send.Output.newBuilder().setAddress(ByteString.copyFrom(address));

    for (Token coin : output.getCoins()) {
        Send.Token protCoin =
                Send.Token.newBuilder().setAmount(coin.getAmount())
                        .setDenom(coin.getDenom()).build();
        builder.addCoins(protCoin);
    }
    return builder.build();
}