Examples with BlockDb neo.model.db.BlockDb used on opensource projects

Example 6 with BlockDb

use of neo.model.db.BlockDb in project neo-java by coranos.

the class RpcServerUtil method onGetCityOfZionClaims.

/**
 * return the available claims of the address.
 *
 * @param controller
 *            the controller to use.
 * @param address
 *            the address to use.
 * @return the balance of the address.
 */
private static JSONObject onGetCityOfZionClaims(final LocalControllerNode controller, final String address) {
    final UInt160 scriptHash = ModelUtil.addressToScriptHash(address);
    if (LOG.isTraceEnabled()) {
        LOG.trace("onGetCityOfZionClaims.scriptHash:{}", scriptHash);
    }
    try {
        final BlockDb blockDb = controller.getLocalNodeData().getBlockDb();
        final Map<UInt256, Map<TransactionOutput, CoinReference>> transactionOutputListMap = controller.getLocalNodeData().getBlockDb().getUnspentTransactionOutputListMap(scriptHash);
        final JSONArray claimJa = new JSONArray();
        if (transactionOutputListMap != null) {
            final Map<TransactionOutput, CoinReference> neoTransactionOutputListMap = transactionOutputListMap.get(ModelUtil.NEO_HASH);
            final Map<TransactionOutput, Long> blockIxByTxoMap = new TreeMap<>();
            final List<Transaction> transactionList = blockDb.getTransactionWithAccountList(scriptHash);
            for (final Transaction transaction : transactionList) {
                final long blockIx = blockDb.getBlockIndexFromTransactionHash(transaction.getHash());
                for (final TransactionOutput to : transaction.outputs) {
                    if (neoTransactionOutputListMap.containsKey(to)) {
                        blockIxByTxoMap.put(to, blockIx);
                    }
                }
            }
            for (final TransactionOutput output : neoTransactionOutputListMap.keySet()) {
                final CoinReference cr = neoTransactionOutputListMap.get(output);
                final JSONObject unspent = toUnspentJSONObject(false, output, cr);
                final JSONObject claim = new JSONObject();
                final String txHashStr = unspent.getString(TXID);
                claim.put(TXID, txHashStr);
                claim.put(INDEX, unspent.getLong(INDEX));
                claim.put(VALUE, unspent.getLong(VALUE));
                final UInt256 txHash = ModelUtil.getUInt256(ByteBuffer.wrap(ModelUtil.decodeHex(txHashStr)), true);
                final long start = blockDb.getBlockIndexFromTransactionHash(txHash);
                claim.put(START, start);
                final long end = blockIxByTxoMap.get(output);
                claim.put(END, end);
                claim.put(SYSFEE, computeSysFee(controller.getLocalNodeData().getTransactionSystemFeeMap(), blockDb, start, end));
                claim.put("claim", calculateBonus(claim));
                claimJa.put(claim);
            }
        }
        final JSONObject response = new JSONObject();
        response.put(ADDRESS, address);
        response.put(CLAIMS, claimJa);
        response.put(NET, controller.getLocalNodeData().getNetworkName());
        return response;
    } catch (final RuntimeException e) {
        LOG.error("onGetCityOfZionClaims", e);
        final JSONObject response = new JSONObject();
        if (e.getMessage() == null) {
            response.put(ERROR, e.getClass().getName());
        } else {
            response.put(ERROR, e.getMessage());
        }
        response.put(EXPECTED, EXPECTED_GENERIC_HEX);
        response.put(ACTUAL, address);
        return response;
    }
}

Example 7 with BlockDb

use of neo.model.db.BlockDb in project neo-java by coranos.

the class BlockImportExportUtil method exportBlocks.

/**
 * exports the blocks to the file.
 *
 * @param controller
 *            the controller.
 */
public static void exportBlocks(final LocalControllerNode controller) {
    final LocalNodeData localNodeData = controller.getLocalNodeData();
    final BlockDb blockDb = localNodeData.getBlockDb();
    try (OutputStream statsFileOut = new FileOutputStream(localNodeData.getChainExportStatsFileName());
        PrintWriter statsWriter = new PrintWriter(statsFileOut, true)) {
        statsWriter.println(OPEN_BRACKET);
        try (DataOutputStream out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(localNodeData.getChainExportDataFileName()), 1024 * 1024 * 32))) {
            final long maxIndex = blockDb.getHeaderOfBlockWithMaxIndex().getIndexAsLong();
            final byte[] maxIndexBa = new UInt32(maxIndex + 1).toByteArray();
            out.write(maxIndexBa);
            if (LOG.isTraceEnabled()) {
                LOG.trace("export maxIndexBa aswritten {}", Hex.encode(maxIndexBa));
            }
            long startMs = -1;
            long interimBlocks = 0;
            long interimBytes = 0;
            final long[] interimTx = new long[TransactionType.values().length];
            final long[] interimTxNetworkFees = new long[TransactionType.values().length];
            long totalTx = 0;
            final Map<String, Long> numBlocksByTxCountMap = new TreeMap<>();
            @SuppressWarnings("unchecked") final Set<UInt160>[] activeAccountSet = new Set[TransactionType.values().length];
            for (int txOrdinal = 0; txOrdinal < activeAccountSet.length; txOrdinal++) {
                activeAccountSet[txOrdinal] = new TreeSet<>();
            }
            long procStartMs = System.currentTimeMillis();
            for (long blockIx = 0; blockIx <= maxIndex; blockIx++) {
                LOG.debug("STARTED export {} of {} ", blockIx, maxIndex);
                final Block block = localNodeData.getBlockDb().getFullBlockFromHeight(blockIx);
                final byte[] ba = block.toByteArray();
                final int length = Integer.reverseBytes(ba.length);
                out.writeInt(length);
                out.write(ba);
                LOG.debug("SUCCESS export {} of {} length {}", blockIx, maxIndex, ba.length);
                final Timestamp blockTs = block.getTimestamp();
                interimBlocks++;
                interimBytes += ba.length;
                for (final Transaction tx : block.getTransactionList()) {
                    interimTx[tx.type.ordinal()]++;
                    final Fixed8 systemFee = localNodeData.getTransactionSystemFeeMap().get(tx.type);
                    interimTxNetworkFees[tx.type.ordinal()] += getNetworkFee(blockDb, tx, systemFee).value;
                    totalTx++;
                    for (final TransactionOutput txOut : tx.outputs) {
                        activeAccountSet[tx.type.ordinal()].add(txOut.scriptHash);
                    }
                }
                MapUtil.increment(numBlocksByTxCountMap, String.valueOf(block.getTransactionList().size()));
                if (startMs < 0) {
                    startMs = blockTs.getTime();
                }
                final long ms = blockTs.getTime() - startMs;
                if (ms > (86400 * 1000)) {
                    out.flush();
                    final Block maxBlockHeader = blockDb.getHeaderOfBlockWithMaxIndex();
                    final JSONObject stats = getStats(blockDb, interimBlocks, interimBytes, interimTx, activeAccountSet, procStartMs, blockTs, interimTxNetworkFees, numBlocksByTxCountMap);
                    if (blockIx > 0) {
                        statsWriter.println(COMMA);
                    }
                    statsWriter.println(stats);
                    LOG.info("INTERIM export {} of {}, bx {}, tx {} json {}", INTEGER_FORMAT.format(blockIx), INTEGER_FORMAT.format(maxIndex), INTEGER_FORMAT.format(maxBlockHeader.getIndexAsLong()), INTEGER_FORMAT.format(totalTx), stats);
                    startMs = blockTs.getTime();
                    for (int ix = 0; ix < interimTx.length; ix++) {
                        interimTx[ix] = 0;
                        interimTxNetworkFees[ix] = 0;
                    }
                    interimBlocks = 0;
                    interimBytes = 0;
                    for (int txOrdinal = 0; txOrdinal < activeAccountSet.length; txOrdinal++) {
                        activeAccountSet[txOrdinal].clear();
                    }
                    numBlocksByTxCountMap.clear();
                    procStartMs = System.currentTimeMillis();
                }
            }
            out.flush();
        } catch (final IOException e) {
            throw new RuntimeException(e);
        } finally {
            statsWriter.println(CLOSE_BRACKET);
        }
    } catch (final IOException e) {
        throw new RuntimeException(e);
    }
}

Example 8 with BlockDb

use of neo.model.db.BlockDb in project neo-java by coranos.

the class TestVm method test999Vm.

@Test
public void test999Vm() {
    LOG.info("STARTED vm");
    final LocalNodeData localNodeData = CONTROLLER.getLocalNodeData();
    final BlockDb blockDb = localNodeData.getBlockDb();
    final long maxIndex = blockDb.getHeaderOfBlockWithMaxIndex().getIndexAsLong();
    long startMs = -1;
    for (long blockHeight = 0; blockHeight <= maxIndex; blockHeight++) {
        LOG.info("STARTED block {} of {} ", blockHeight, maxIndex);
        final Block block = blockDb.getFullBlockFromHeight(blockHeight);
        final int maxTxIx = block.getTransactionList().size();
        for (int txIx = 0; txIx < maxTxIx; txIx++) {
            final Transaction tx = block.getTransactionList().get(txIx);
            if (tx.type.equals(TransactionType.ISSUE_TRANSACTION)) {
                LOG.info("SKIPPED block {} of {} tx {} of {} : {}", blockHeight, maxIndex, txIx, maxTxIx, tx.getHash());
            } else {
                LOG.info("STARTED block {} of {} tx {} of {} : {} {}", blockHeight, maxIndex, txIx, maxTxIx, tx.type, tx.getHash());
                final ScriptVerificationResultEnum verifyScriptsResult = VerifyScriptUtil.verifyScripts(blockDb, tx);
                if (!verifyScriptsResult.equals(ScriptVerificationResultEnum.PASS)) {
                    LOG.error("FAILURE block {} of {} tx {} of {} : {} {} : {}", blockHeight, maxIndex, txIx, maxTxIx, tx.type, tx.getHash(), verifyScriptsResult);
                    throw new RuntimeException("script failed : " + tx.type + ":" + verifyScriptsResult);
                } else {
                    LOG.info("SUCCESS block {} of {} tx {} of {} : {} {}", blockHeight, maxIndex, txIx, maxTxIx, tx.type, tx.getHash());
                }
            }
        }
        final Timestamp blockTs = block.getTimestamp();
        if (startMs < 0) {
            startMs = blockTs.getTime();
        }
        final long ms = blockTs.getTime() - startMs;
        if (ms > (86400 * 1000)) {
            final String targetDateStr = DATE_FORMAT.format(blockTs);
            LOG.info("INTERIM vm {} of {}, date {}", INTEGER_FORMAT.format(blockHeight), INTEGER_FORMAT.format(maxIndex), targetDateStr);
            startMs = blockTs.getTime();
        }
    }
    LOG.debug("SUCCESS vm");
}

Example 9 with BlockDb

use of neo.model.db.BlockDb in project neo-java by coranos.

the class TestAccountPng method test001GetAccountSankey.

@Test
public void test001GetAccountSankey() throws JSONException, IOException {
    LOG.debug("STARTED png");
    final LocalNodeData localNodeData = CONTROLLER.getLocalNodeData();
    final BlockDb blockDb = localNodeData.getBlockDb();
    final long maxIndex = blockDb.getHeaderOfBlockWithMaxIndex().getIndexAsLong();
    final CoinData neoData = new CoinData();
    final CoinData gasData = new CoinData();
    final Map<UInt256, CoinData> coinDataMap = new TreeMap<>();
    coinDataMap.put(ModelUtil.NEO_HASH, neoData);
    coinDataMap.put(ModelUtil.GAS_HASH, gasData);
    final File dir = new File("/Users/dps/git-coranos.github.io/neo/charts");
    final Map<UInt256, File> coinFileMap = new TreeMap<>();
    coinFileMap.put(ModelUtil.NEO_HASH, new File(dir, "neo-account.png"));
    coinFileMap.put(ModelUtil.GAS_HASH, new File(dir, "gas-account.png"));
    long startMs = -1;
    for (long blockIx = 0; blockIx <= maxIndex; blockIx++) {
        LOG.debug("STARTED png {} of {} ", blockIx, maxIndex);
        final Block block = blockDb.getFullBlockFromHeight(blockIx);
        for (final Transaction t : block.getTransactionList()) {
            // update assets based on tx inputs.
            for (final CoinReference cr : t.inputs) {
                final TransactionOutput ti = ModelUtil.getTransactionOutput(blockDb, cr);
                if (coinDataMap.containsKey(ti.assetId)) {
                    final CoinData coinData = coinDataMap.get(ti.assetId);
                    final UInt160 input = ti.scriptHash;
                    if (!coinData.accountValueMap.containsKey(input)) {
                        coinData.accountValueMap.put(input, ModelUtil.FIXED8_ZERO);
                        coinData.newAccountSet.add(input);
                    }
                    final Fixed8 oldValue = coinData.accountValueMap.get(input);
                    final Fixed8 newValue = ModelUtil.subtract(ti.value, oldValue);
                    if (newValue.equals(ModelUtil.FIXED8_ZERO)) {
                        coinData.accountValueMap.remove(input);
                    } else {
                        coinData.accountValueMap.put(input, newValue);
                    }
                }
            }
            // update assets based on tx outputs.
            for (int outputIx = 0; outputIx < t.outputs.size(); outputIx++) {
                final TransactionOutput to = t.outputs.get(outputIx);
                final UInt160 output = to.scriptHash;
                if (coinDataMap.containsKey(to.assetId)) {
                    final CoinData coinData = coinDataMap.get(to.assetId);
                    coinData.txAccountSet.add(output);
                    if (!coinData.accountValueMap.containsKey(output)) {
                        coinData.accountValueMap.put(output, ModelUtil.FIXED8_ZERO);
                        coinData.newAccountSet.add(output);
                    }
                    final Fixed8 oldValue = coinData.accountValueMap.get(output);
                    final Fixed8 newValue = ModelUtil.add(oldValue, to.value);
                    if (newValue.equals(ModelUtil.FIXED8_ZERO)) {
                        coinData.accountValueMap.remove(output);
                    } else {
                        coinData.accountValueMap.put(output, newValue);
                    }
                }
            }
            for (final UInt256 assetId : coinDataMap.keySet()) {
                final CoinData coinData = coinDataMap.get(assetId);
                for (final UInt160 txAccount : coinData.txAccountSet) {
                    MapUtil.increment(coinData.newAccountTxCountMap, txAccount);
                }
                coinData.txAccountSet.clear();
            }
        }
        final Timestamp blockTs = block.getTimestamp();
        if (startMs < 0) {
            startMs = blockTs.getTime();
        }
        final long ms = blockTs.getTime() - startMs;
        if (ms > (86400 * 1000)) {
            final String targetDateStr = DATE_FORMAT.format(blockTs);
            for (final UInt256 assetId : coinDataMap.keySet()) {
                final CoinData coinData = coinDataMap.get(assetId);
                final List<UInt160> accountList = new ArrayList<>();
                accountList.addAll(coinData.accountValueMap.keySet());
                Collections.sort(accountList, new Comparator<UInt160>() {

                    @Override
                    public int compare(final UInt160 account1, final UInt160 account2) {
                        final Long value1 = coinData.accountValueMap.get(account1).value;
                        final Long value2 = coinData.accountValueMap.get(account2).value;
                        return value1.compareTo(value2);
                    }
                });
                Collections.reverse(accountList);
                long maxTx = 0;
                long totalValue = 0;
                {
                    final List<DrawingData> drawingData = new ArrayList<>();
                    coinData.drawingDataList.add(drawingData);
                    int startDayPixel = 0;
                    int visibleAccountCount = 0;
                    for (final UInt160 account : accountList) {
                        totalValue += coinData.accountValueMap.get(account).value;
                    }
                    for (final UInt160 account : accountList) {
                        final int scaleLength = getScaleLength(coinData.accountValueMap, account, totalValue);
                        if (scaleLength != 0) {
                            visibleAccountCount++;
                        }
                        MapUtil.touch(coinData.newAccountTxCountMap, account);
                        maxTx = Math.max(maxTx, coinData.newAccountTxCountMap.get(account));
                    }
                    final float greenStep = 1.0f / visibleAccountCount;
                    final float redStep = 1.0f / maxTx;
                    float green = 1.0f;
                    for (final UInt160 account : accountList) {
                        final int scaleLength = getScaleLength(coinData.accountValueMap, account, totalValue);
                        if (scaleLength != 0) {
                            final float blue;
                            if (coinData.newAccountSet.contains(account)) {
                                blue = 1.0f;
                            } else {
                                blue = 0.0f;
                            }
                            float red = 0.0f;
                            if (coinData.newAccountTxCountMap.containsKey(account)) {
                                red = redStep * coinData.newAccountTxCountMap.get(account);
                            } else {
                                red = 0.0f;
                            }
                            drawingData.add(new DrawingData(startDayPixel, scaleLength, red, green, blue));
                        }
                        green -= greenStep;
                        startDayPixel += scaleLength;
                    }
                }
                final BufferedImage im = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
                final Graphics2D g = (Graphics2D) im.getGraphics();
                g.scale((WIDTH * 1.0) / coinData.drawingDataList.size(), 1.0 / HEIGHT_SUBPIXELS);
                for (int x = 0; x < coinData.drawingDataList.size(); x++) {
                    final List<DrawingData> drawingData = coinData.drawingDataList.get(x);
                    for (final DrawingData drawing : drawingData) {
                        g.setColor(new Color(drawing.r, drawing.g, drawing.b));
                        g.fillRect(x, drawing.y, 1, drawing.h);
                        g.setColor(Color.black);
                        g.drawLine(x, drawing.y, x + 1, drawing.y);
                    }
                }
                g.dispose();
                final File file = coinFileMap.get(assetId);
                ImageIO.write(im, "png", file);
                LOG.info("INTERIM file {}, {} of {}, date {}, accountList {}, tx {}, value {}", file.getName(), INTEGER_FORMAT.format(blockIx), INTEGER_FORMAT.format(maxIndex), targetDateStr, INTEGER_FORMAT.format(accountList.size()), INTEGER_FORMAT.format(maxTx), INTEGER_FORMAT.format(totalValue / ModelUtil.DECIMAL_DIVISOR));
                startMs = blockTs.getTime();
                coinData.newAccountSet.clear();
                coinData.newAccountTxCountMap.clear();
            }
        }
    }
    LOG.debug("SUCCESS png");
}

Example 10 with BlockDb

use of neo.model.db.BlockDb in project neo-java by coranos.

the class RpcServerUtil method onGetCityOfZionBalance.

/**
 * return the balance of the address.
 *
 * @param controller
 *            the controller to use.
 * @param address
 *            the address to use.
 * @return the balance of the address.
 */
private static JSONObject onGetCityOfZionBalance(final LocalControllerNode controller, final String address) {
    final UInt160 scriptHash = ModelUtil.addressToScriptHash(address);
    if (LOG.isTraceEnabled()) {
        LOG.trace("onGetCityOfZionBalance.scriptHash:{}", scriptHash);
    }
    try {
        final BlockDb blockDb = controller.getLocalNodeData().getBlockDb();
        final Map<UInt256, Fixed8> assetValueMap = blockDb.getAssetValueMap(scriptHash);
        final Map<UInt256, Map<TransactionOutput, CoinReference>> transactionOutputListMap = blockDb.getUnspentTransactionOutputListMap(scriptHash);
        if (assetValueMap == null) {
            final JSONObject response = new JSONObject();
            response.put(GAS, new JSONObject());
            response.put(NEO, new JSONObject());
            response.put(NET, controller.getLocalNodeData().getNetworkName());
            return response;
        }
        final Fixed8 neo = assetValueMap.get(ModelUtil.NEO_HASH);
        final Fixed8 gas = assetValueMap.get(ModelUtil.GAS_HASH);
        final JSONObject response = new JSONObject();
        final JSONObject neoJo = new JSONObject();
        neoJo.put(UNSPENT, toUnspentJSONArray(transactionOutputListMap.get(ModelUtil.NEO_HASH), false));
        neoJo.put(BALANCE, neo);
        final JSONObject gasJo = new JSONObject();
        gasJo.put(UNSPENT, toUnspentJSONArray(transactionOutputListMap.get(ModelUtil.GAS_HASH), true));
        gasJo.put(BALANCE, gas);
        response.put(GAS, gasJo);
        response.put(NEO, neoJo);
        response.put(NET, controller.getLocalNodeData().getNetworkName());
        return response;
    } catch (final RuntimeException e) {
        LOG.error("onGetCityOfZionBalance", e);
        final JSONObject response = new JSONObject();
        if (e.getMessage() == null) {
            response.put(ERROR, e.getClass().getName());
        } else {
            response.put(ERROR, e.getMessage());
        }
        response.put(EXPECTED, EXPECTED_GENERIC_HEX);
        response.put(ACTUAL, address);
        return response;
    }
}