锯齿形java发送批处理请求错误

我正在尝试使用Sawtooth java SDK发送批处理

1） -我正在通过sawtooth CLI生成密钥

2） -我正在使用处理客户请求

3） -我构建批处理查询

4） -发送查询后，我在响应中始终处于无效状态。此外，我的处理器日志中也有此消息（“应用程序->应用错误状态获取授权错误。检查事务输入”）

请帮帮我。（我的客户代码如下）

公共班机{

public static void main(String[] args) throws UnirestException, NoSuchAlgorithmException {


    ECKey privateKey = Signing.readWif(getWifKey("c1783ac6bf55910ab9bfa6defbd7b819a5b29032dd281fa1976363fd6e08d59d")); //generated pk by sawtooth keygen
    String publicKey = Signing.getPublicKey(privateKey);

    ByteString publicKeyByteString = ByteString.copyFromUtf8(publicKey);

    String payload = "deposit,50,02e664d454c7841ae1e2bd9a597dd12b2fa09f9389b29ab9fda6220674ff7bc7b8";
    String payloadBytes = Utils.hash512(payload.getBytes());
    ByteString payloadByteString = ByteString.copyFrom(payload.getBytes());

    TransactionHeader txnHeader = TransactionHeader.newBuilder()
            .setBatcherPublicKeyBytes(publicKeyByteString)
            .setSignerPublicKeyBytes(publicKeyByteString)
            .setFamilyName("simplewallet")
            .setFamilyVersion("1.0")
            .addInputs(publicKey)
            .setNonce("1")
            .addOutputs("02e664d454c7841ae1e2bd9a597dd12b2fa09f9389b29ab9fda6220674ff7bc7b8")//recipient public key
            .setPayloadSha512(payloadBytes)
            .setSignerPublicKey(publicKey)
            .build();
    ByteString txnHeaderBytes = txnHeader.toByteString();
    String txnHeaderSignature = Signing.sign(privateKey, txnHeaderBytes.toByteArray());

    Transaction txn = Transaction.newBuilder()
            .setHeader(txnHeaderBytes)
            .setPayload(payloadByteString)
            .setHeaderSignature(txnHeaderSignature)
            .build();

    BatchHeader batchHeader = BatchHeader.newBuilder()
            .setSignerPublicKey(publicKey)
            .addTransactionIds(txn.getHeaderSignature())
            .build();
    ByteString batchHeaderBytes = batchHeader.toByteString();
    String batchHeaderSignature = Signing.sign(privateKey, batchHeaderBytes.toByteArray());

    Batch batch = Batch.newBuilder()
            .setHeader(batchHeaderBytes)
            .setHeaderSignature(batchHeaderSignature)
            .addTransactions(txn)
            .build();

    BatchList batchList = BatchList.newBuilder()
            .addBatches(batch)
            .build();
    ByteString batchBytes = batchList.toByteString();

    String serverResponse = Unirest.post("http://localhost:8008/batches")
            .header("Content-Type", "application/octet-stream")
            .body(batchBytes.toByteArray())
            .asString()
            .getBody();

    System.out.println(serverResponse);

}

private static String getWifKey(String sourceKey) throws NoSuchAlgorithmException {

    sourceKey = "80" + sourceKey;

    byte[] pkByteArr = hexStringToByteArray(sourceKey);

    MessageDigest digest = MessageDigest.getInstance("SHA-256");
    byte[] hash = digest.digest(pkByteArr);

    byte[] secondHash = digest.digest(hash);

    byte[] resPkBytes = new byte[pkByteArr.length + 4];

    System.arraycopy(pkByteArr, 0, resPkBytes, 0, pkByteArr.length);

    System.arraycopy(secondHash, 0, resPkBytes, pkByteArr.length, 4);

    return Base58.encode(resPkBytes);
}

private static byte[] hexStringToByteArray(String s) {
    int len = s.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        data[i / 2] = (byte) ((Character.digit(s.charAt(i), 16) << 4)
                + Character.digit(s.charAt(i + 1), 16));
    }
    return data;
}

publicstaticvoidmain（字符串[]args）抛出UnirestException、nosuchalgorithException{
ECKey privateKey=Signing.readWif（getWifKey（“c1783ac6bf55910ab9bfa6defbd7b819a5b29032dd281fa1976363fd6e08d59d”）；//由锯齿键生成pk
字符串publicKey=Signing.getPublicKey（privateKey）；
ByteString publicKeyByteString=ByteString.copyFromUtf8（publicKey）；
字符串有效载荷=“存款，50,02e664d454c7841ae1e2bd9a597dd12b2fa09f9389b29ab9fda6220674ff7bc7b8”；
字符串payloadBytes=Utils.hash512（payload.getBytes（））；
ByteString payloadByteString=ByteString.copyFrom（payload.getBytes（））；
TransactionHeader txnHeader=TransactionHeader.newBuilder（）
.setBatcherPublicKeyBytes（publicKeyByteString）
.SetSignerPublicKeyByByByByBytes（publicKeyByteString）
.setFamilyName（“simplewallet”）
.setFamilyVersion（“1.0”）
.addInputs（公钥）
.setNonce（“1”）
.addOutputs（“02e664d454c7841ae1e2bd9a597dd12b2fa09f9389b29ab9fda6220674ff7bc7b8”）//收件人公钥
.setPayloadSha512（payloadBytes）
.setSignerPublicKey（公钥）
.build（）；
ByteString txnHeaderBytes=txnHeader.toByteString（）；
字符串txnHeaderSignature=Signing.sign（privateKey，txnHeaderBytes.toByteArray（））；
事务txn=Transaction.newBuilder（）
.setHeader（txnHeaderBytes）
.setPayload（payloadByteString）
.setHeaderSignature（txnHeaderSignature）
.build（）；
BatchHeader BatchHeader=BatchHeader.newBuilder（）
.setSignerPublicKey（公钥）
.addTransactionId（txn.getHeaderSignature（））
.build（）；
ByteString batchHeaderBytes=batchHeader.toByteString（）；
字符串batchHeaderSignature=Signing.sign（privateKey，batchHeaderBytes.toByteArray（））；
Batch=Batch.newBuilder（）
.setHeader（batchHeaderBytes）
.setHeaderSignature（批次HeaderSignature）
.addTransactions（txn）
.build（）；
BatchList BatchList=BatchList.newBuilder（）
.addBatches（批处理）
.build（）；
ByteString batchBytes=batchList.toByteString（）；
字符串serverResponse=Unirest.post（“http://localhost:8008/batches")
.header（“内容类型”、“应用程序/八位字节流”）
.body（batchBytes.toByteArray（））
.asString（）
.getBody（）；
System.out.println（服务器响应）；
}
私有静态字符串getWifKey（字符串sourceKey）抛出NoSuchAlgorithmException{
sourceKey=“80”+sourceKey；
字节[]pkByteArr=hexStringToByteArray（sourceKey）；
MessageDigest=MessageDigest.getInstance（“SHA-256”）；
字节[]散列=digest.digest（pkByteArr）；
字节[]secondHash=digest.digest（散列）；
字节[]reskbytes=新字节[pkByteArr.length+4]；
数组复制（pkByteArr，0，reskbytes，0，pkByteArr.length）；
System.arraycopy（secondHash，0，reskbytes，pkByteArr.length，4）；
返回Base58.encode（reskbytes）；
}
私有静态字节[]hexStringToByteArray（字符串s）{
int len=s.length（）；
字节[]数据=新字节[len/2]；
对于（int i=0；i数据[i/2]=（字节）（（Character.digit（s.charAt（i），16）表示事务批由事务处理器处理，但事务处理器将其标记为无效。这可能是因为序列化或反序列化问题

下面是一个使用Java客户端（和其他编程语言）的简单锯齿应用程序示例：
Thank's（例如，感谢）