Java TransactionResult類代碼示例

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
void fillInLedger(final PendingLedger ledger) {
    final long ledger_index = ledger.ledger_index;
    ledger.setStatus(PendingLedger.Status.fillingIn);

    requestLedger(ledger_index, false, new Callback<Response>() {
        @Override
        public void called(Response response) {
            JSONObject ledgerJSON = response.result.getJSONObject("ledger");
            JSONArray transactions = ledgerJSON.getJSONArray("transactions");

            for (int i = 0; i < transactions.length(); i++) {
                JSONObject json = transactions.getJSONObject(i);
                // This is kind of nasty
                json.put("ledger_index", ledger_index);
                json.put("validated",    true);
                TransactionResult tr = TransactionResult.fromJSON(json);
                ledger.notifyTransaction(tr);
            }

            final String transaction_hash = ledgerJSON.getString("transaction_hash");
            boolean correctHash = ledger.transactionHashEquals(transaction_hash);
            if (!correctHash) throw new IllegalStateException("We don't handle invalid transactions yet");
            clearLedger(ledger_index, "fillInLedger");
        }
    });
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public void updateFromTransactionResult(TransactionResult tr) {
    if (!tr.validated) {
        return;
    }

    TransactionMeta meta = tr.meta;
    UInt32 ledgerIndex = tr.ledgerIndex;
    UInt32 txnIndex = meta.transactionIndex();

    for (AffectedNode an : meta.affectedNodes()) {
        Hash256 index = an.ledgerIndex();
        CacheEntry ce = getOrCreate(index);
        ce.upateLedgerEntry(an.isDeletedNode() ? null : (LedgerEntry) an.nodeAsFinal(),
                            ledgerIndex,
                            txnIndex);
    }
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
void onTransaction(JSONObject msg) {
    TransactionResult tr = new TransactionResult(msg, TransactionResult
            .Source
            .transaction_subscription_notification);
    if (tr.validated) {
        if (transactionSubscriptionManager != null) {
            transactionSubscriptionManager.notifyTransactionResult(tr);
        } else {
            onTransactionResult(tr);
        }
    }
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public void onTransactionResult(TransactionResult tr) {
    log(Level.INFO, "Transaction {0} is validated", tr.hash);
    Map<AccountID, STObject> affected = tr.modifiedRoots();

    if (affected != null) {
        Hash256 transactionHash = tr.hash;
        UInt32 transactionLedgerIndex = tr.ledgerIndex;

        for (Map.Entry<AccountID, STObject> entry : affected.entrySet()) {
            Account account = accounts.get(entry.getKey());
            if (account != null) {
                STObject rootUpdates = entry.getValue();
                account.getAccountRoot()
                        .updateFromTransaction(
                                transactionHash, transactionLedgerIndex, rootUpdates);
            }
        }
    }

    Account initator = accounts.get(tr.initiatingAccount());
    if (initator != null) {
        log(Level.INFO, "Found initiator {0}, notifying transactionManager", initator);
        initator.transactionManager().notifyTransactionResult(tr);
    } else {
        log(Level.INFO, "Can't find initiating account!");
    }
    emit(OnValidatedTransaction.class, tr);
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public void requestTransaction(final Hash256 hash, final Manager<TransactionResult> cb) {
    makeManagedRequest(Command.tx, cb, new Request.Builder<TransactionResult>() {
        @Override
        public void beforeRequest(Request request) {
            request.json("binary", true);
            request.json("transaction", hash);
        }

        @Override
        public TransactionResult buildTypedResponse(Response response) {
            return new TransactionResult(response.result, TransactionResult.Source.request_tx_binary);
        }
    });
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public void notifyTransactionResult(TransactionResult tr) {
    long key = tr.ledgerIndex.longValue();
    if (clearedLedgers.contains(key)) {
        System.out.println("warning");
        return;
    }

    PendingLedger ledger = getOrAddLedger(key);
    ledger.notifyTransaction(tr);
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public void notifyTransaction(TransactionResult tr) {
    if (!transactions.hasLeaf(tr.hash)) {
        clearedTransactions++;
        transactions.addTransactionResult(tr);
        client.onTransactionResult(tr);
        logStateChange();
    }
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
@Override
public void onPage(AccountTxPager.Page page) {
    lastTxnRequesterUpdate = client.serverInfo.ledger_index;

    if (page.hasNext()) {
        page.requestNext();
    } else {
        lastLedgerCheckedAccountTxns = Math.max(lastLedgerCheckedAccountTxns, page.ledgerMax());
        txnPager = null;
    }

    for (TransactionResult tr : page.transactionResults()) {
        notifyTransactionResult(tr);
    }
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public ManagedTxn onValidated(final Callback<ManagedTxn> handler) {
    on(OnTransactionValidated.class, new OnTransactionValidated() {
        @Override
        public void called(TransactionResult args) {
            result = args;
            handler.called(ManagedTxn.this);
        }
    });
    return this;
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
private static void printTrade(TransactionResult tr,
                               Offer before,
                               Offer after) {
    // Executed define non negative amount of Before - After
    STObject executed = after.executed(before);
    Amount takerGot = executed.get(Amount.TakerGets);

    // Only print trades that executed
    if (!takerGot.isZero()) {
        print("In {0} tx: {1}, Offer owner {2}, was paid: {3}, gave: {4} ",
              tr.transactionType(), tr.hash, before.account(),
                executed.get(Amount.TakerPays), takerGot);
    }
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public void notifyTransactionResult(TransactionResult tr) {
    ledgers.notifyTransactionResult(tr);
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
private void onTransactions(JSONObject responseResult) {
    final JSONArray transactions = responseResult.getJSONArray("transactions");
    final int ledger_index_max = responseResult.optInt("ledger_index_max");
    final int ledger_index_min = responseResult.optInt("ledger_index_min");
    final Object newMarker = responseResult.opt("marker");

    onPage.onPage(new Page() {
        ArrayList<TransactionResult> txns = null;

        @Override
        public boolean hasNext() {
            return newMarker != null;
        }

        @Override
        public void requestNext() {
            if (hasNext()) {
                walkAccountTx(newMarker);
            }
        }

        @Override
        public long ledgerMax() {
            return ledger_index_max;
        }

        @Override
        public long ledgerMin() {
            return ledger_index_min;
        }

        @Override
        public int size() {
            return transactions.length();
        }

        @Override
        public ArrayList<TransactionResult> transactionResults() {
            if (txns == null) {
                txns = new ArrayList<TransactionResult>();
                for (int i = 0; i < transactions.length(); i++) {
                    JSONObject jsonObject = transactions.optJSONObject(i);
                    txns.add(new TransactionResult(jsonObject,
                            TransactionResult.Source.request_account_tx_binary));
                }
            }
            return txns;
        }

        @Override
        public JSONArray transactionsJSON() {
            return transactions;
        }
    });
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
public TransactionResultItem(TransactionResult result) {
    this.result = result;
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
@Override
public ShaMapItem<TransactionResult> copy() {
    // that's ok right ;) these bad boys are immutable anyway
    return this;
}
 

import com.ripple.core.types.known.tx.result.TransactionResult; //導入依賴的package包/類
@Override
public TransactionResult value() {
    return result;
}