Example #1
1
 @Override
 JSONStreamAware processRequest(HttpServletRequest req) {
   JSONObject response = new JSONObject();
   long longId = Convert.fullHashToId(Convert.parseHexString(req.getParameter("fullHash")));
   response.put("longId", String.valueOf(longId));
   response.put("stringId", Long.toUnsignedString(longId));
   return response;
 }
 @Override
 public void run() {
   String shareRequest =
       plotFile.getAddress()
           + ":"
           + nonce
           + ":"
           + processing.getHeight()
           + " deadline {"
           + deadline
           + "}";
   LOGGER.info("Submitting share {" + shareRequest + "}");
   try {
     if (poolType.equals(POOL_TYPE_URAY)) {
       String request =
           poolUrl
               + "/burst?requestType=submitNonce&secretPhrase=pool-mining&nonce="
               + Convert.toUnsignedLong(nonce)
               + "&accountId="
               + Convert.toUnsignedLong(plotFile.getAddress());
       String response = restTemplate.postForObject(request, shareRequest, String.class);
       LOGGER.info("Response {" + response + "}}");
       plotFile.addShare();
     } else if (poolType.equals(POOL_TYPE_OFFICIAL)) {
       shareRequest = plotFile.getAddress() + ":" + nonce + ":" + processing.getHeight() + "\n";
       String response =
           restTemplate.postForObject(poolUrl + "/pool/submitWork", shareRequest, String.class);
       LOGGER.info("Response {" + response + "}}");
       plotFile.addShare();
     }
     lastShareSubmitTime = System.currentTimeMillis();
   } catch (Exception ex) {
     LOGGER.info("Failed to submitShare {" + shareRequest + "}");
   }
 }
  @Override
  JSONStreamAware processRequest(HttpServletRequest req) {

    String accountIdString = Convert.emptyToNull(req.getParameter("account"));
    Long accountId = null;

    if (accountIdString != null) {
      try {
        accountId = Convert.parseUnsignedLong(accountIdString);
      } catch (RuntimeException e) {
        return INCORRECT_ACCOUNT;
      }
    }

    JSONArray transactionIds = new JSONArray();
    for (Transaction transaction : Nxt.getTransactionProcessor().getAllUnconfirmedTransactions()) {
      if (accountId != null
          && !(accountId.equals(transaction.getSenderId())
              || accountId.equals(transaction.getRecipientId()))) {
        continue;
      }
      transactionIds.add(transaction.getStringId());
    }

    JSONObject response = new JSONObject();
    response.put("unconfirmedTransactionIds", transactionIds);
    return response;
  }
Example #4
0
  public static String generateHallmark(String secretPhrase, String host, int weight, int date) {

    if (host.length() == 0 || host.length() > 100) {
      throw new IllegalArgumentException("Hostname length should be between 1 and 100");
    }
    if (weight <= 0 || weight > Constants.MAX_BALANCE_NXT) {
      throw new IllegalArgumentException(
          "Weight should be between 1 and " + Constants.MAX_BALANCE_NXT);
    }

    byte[] publicKey = Crypto.getPublicKey(secretPhrase);
    byte[] hostBytes = Convert.toBytes(host);

    ByteBuffer buffer = ByteBuffer.allocate(32 + 2 + hostBytes.length + 4 + 4 + 1);
    buffer.order(ByteOrder.LITTLE_ENDIAN);
    buffer.put(publicKey);
    buffer.putShort((short) hostBytes.length);
    buffer.put(hostBytes);
    buffer.putInt(weight);
    buffer.putInt(date);

    byte[] data = buffer.array();
    data[data.length - 1] = (byte) ThreadLocalRandom.current().nextInt();
    byte[] signature = Crypto.sign(data, secretPhrase);

    return Convert.toHexString(data) + Convert.toHexString(signature);
  }
  @Override
  JSONStreamAware processRequest(HttpServletRequest req) throws NxtException {

    long accountId = ParameterParser.getAccount(req).getId();
    long assetId = 0;
    try {
      assetId = Convert.parseUnsignedLong(req.getParameter("asset"));
    } catch (RuntimeException e) {
      // ignore
    }
    int firstIndex = ParameterParser.getFirstIndex(req);
    int lastIndex = ParameterParser.getLastIndex(req);

    DbIterator<Order.Ask> askOrders;
    if (assetId == 0) {
      askOrders = Order.Ask.getAskOrdersByAccount(accountId, firstIndex, lastIndex);
    } else {
      askOrders = Order.Ask.getAskOrdersByAccountAsset(accountId, assetId, firstIndex, lastIndex);
    }
    JSONArray orderIds = new JSONArray();
    try {
      while (askOrders.hasNext()) {
        orderIds.add(Convert.toUnsignedLong(askOrders.next().getId()));
      }
    } finally {
      askOrders.close();
    }
    JSONObject response = new JSONObject();
    response.put("askOrderIds", orderIds);
    return response;
  }
Example #6
0
 @Override
 public Object getCellValue(Object element) {
   ITransaction transaction = (ITransaction) element;
   Transaction t = transaction.getNative();
   if (accountId.equals(t.getSenderId())) {
     return Convert.toUnsignedLong(t.getRecipientId());
   }
   return Convert.toUnsignedLong(t.getSenderId());
 }
 @Test
 public void sha256() {
   byte[] hash = HashFunction.SHA256.hash(new byte[] {0x61, 0x62, 0x63});
   Assert.assertEquals(
       "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
       Convert.toHexString(hash));
   hash = HashFunction.SHA256.hash(new byte[] {});
   Assert.assertEquals(
       "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
       Convert.toHexString(hash));
 }
Example #8
0
 @Override
 public String toString() {
   return "AccountAsset account_id: "
       + Convert.toUnsignedLong(accountId)
       + " asset_id: "
       + Convert.toUnsignedLong(assetId)
       + " quantity: "
       + quantityQNT
       + " unconfirmedQuantity: "
       + unconfirmedQuantityQNT;
 }
 @Test
 public void sha3() {
   byte[] hash = HashFunction.SHA3.hash(new byte[] {(byte) 0x41, (byte) 0xFB});
   Assert.assertEquals(
       "A8EACEDA4D47B3281A795AD9E1EA2122B407BAF9AABCB9E18B5717B7873537D2".toLowerCase(),
       Convert.toHexString(hash));
   hash = HashFunction.SHA3.hash(new byte[] {});
   Assert.assertEquals(
       "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470",
       Convert.toHexString(hash));
 }
Example #10
0
 @Test
 public void scrypt() {
   byte[] hash = HashFunction.SCRYPT.hash(new byte[] {(byte) 0x41, (byte) 0xFB});
   Assert.assertEquals(
       "da3f4f010d772567a8896465d11df28693b244c91b8ba4bea5a30f6be572b667".toLowerCase(),
       Convert.toHexString(hash));
   hash = HashFunction.SCRYPT.hash(new byte[] {});
   Assert.assertEquals(
       "0cf2967ca5c120e80b37f8f75c971842e05da107278c1058e6ffbc68911c11f1",
       Convert.toHexString(hash));
 }
Example #11
0
 void addToBalanceAndUnconfirmedBalanceNQT(long amountNQT) {
   if (amountNQT == 0) {
     return;
   }
   this.balanceNQT = Convert.safeAdd(this.balanceNQT, amountNQT);
   this.unconfirmedBalanceNQT = Convert.safeAdd(this.unconfirmedBalanceNQT, amountNQT);
   addToGuaranteedBalanceNQT(amountNQT);
   checkBalance(this.id, this.balanceNQT, this.unconfirmedBalanceNQT);
   accountTable.insert(this);
   listeners.notify(this, Event.BALANCE);
   listeners.notify(this, Event.UNCONFIRMED_BALANCE);
 }
Example #12
0
  protected void doGet(HttpServletRequest req, HttpServletResponse resp)
      throws ServletException, IOException {

    resp.setHeader("Cache-Control", "no-cache, no-store, must-revalidate, private");
    resp.setHeader("Pragma", "no-cache");
    resp.setDateHeader("Expires", 0);
    resp.setContentType("text/html; charset=UTF-8");

    if (API.allowedBotHosts != null && !API.allowedBotHosts.contains(req.getRemoteHost())) {
      resp.sendError(HttpServletResponse.SC_FORBIDDEN);
      return;
    }

    try (PrintWriter writer = resp.getWriter()) {
      writer.print(header1);
      writer.print(buildLinks(req));
      writer.print(header2);
      String requestType = Convert.nullToEmpty(req.getParameter("requestType"));
      APIServlet.APIRequestHandler requestHandler = APIServlet.apiRequestHandlers.get(requestType);
      StringBuilder bufJSCalls = new StringBuilder();
      if (requestHandler != null) {
        writer.print(
            form(
                requestType,
                true,
                requestHandler.getClass().getName(),
                requestHandler.getParameters(),
                requestHandler.requirePost()));
        bufJSCalls.append("apiCalls.push(\"").append(requestType).append("\");\n");
      } else {
        String requestTag = Convert.nullToEmpty(req.getParameter("requestTag"));
        Set<String> taggedTypes = requestTags.get(requestTag);
        for (String type : (taggedTypes != null ? taggedTypes : allRequestTypes)) {
          requestHandler = APIServlet.apiRequestHandlers.get(type);
          writer.print(
              form(
                  type,
                  false,
                  requestHandler.getClass().getName(),
                  APIServlet.apiRequestHandlers.get(type).getParameters(),
                  APIServlet.apiRequestHandlers.get(type).requirePost()));
          bufJSCalls.append("apiCalls.push(\"").append(type).append("\");\n");
        }
      }
      writer.print(footer1);
      writer.print(bufJSCalls.toString());
      writer.print(footer2);
    }
  }
Example #13
0
                @Override
                public Object getCellValue(Object element) {
                  ITransaction transaction = (ITransaction) element;
                  Transaction t = transaction.getNative();

                  IContact contact;
                  if (t.getSenderId().equals(accountId))
                    contact =
                        getContactsService().getContact(Convert.toUnsignedLong(t.getRecipientId()));
                  else
                    contact =
                        getContactsService().getContact(Convert.toUnsignedLong(t.getSenderId()));
                  if (contact != null) return contact.getName();

                  return EMPTY_STRING;
                }
Example #14
0
 public static Account getAccount(byte[] publicKey) {
   Account account = accountTable.get(accountDbKeyFactory.newKey(getId(publicKey)));
   if (account == null) {
     return null;
   }
   if (account.getPublicKey() == null || Arrays.equals(account.getPublicKey(), publicKey)) {
     return account;
   }
   throw new RuntimeException(
       "DUPLICATE KEY for account "
           + Convert.toUnsignedLong(account.getId())
           + " existing key "
           + Convert.toHexString(account.getPublicKey())
           + " new key "
           + Convert.toHexString(publicKey));
 }
Example #15
0
  @Override
  JSONStreamAware processRequest(HttpServletRequest req) {

    String[] assets = req.getParameterValues("assets");
    boolean includeCounts = !"false".equalsIgnoreCase(req.getParameter("includeCounts"));

    JSONObject response = new JSONObject();
    JSONArray assetsJSONArray = new JSONArray();
    response.put("assets", assetsJSONArray);
    for (String assetIdString : assets) {
      if (assetIdString == null || assetIdString.equals("")) {
        continue;
      }
      try {
        Asset asset = Asset.getAsset(Convert.parseUnsignedLong(assetIdString));
        if (asset == null) {
          return UNKNOWN_ASSET;
        }
        assetsJSONArray.add(JSONData.asset(asset, includeCounts));
      } catch (RuntimeException e) {
        return INCORRECT_ASSET;
      }
    }
    return response;
  }
Example #16
0
 private void addToGuaranteedBalanceNQT(long amountNQT) {
   if (amountNQT <= 0) {
     return;
   }
   int blockchainHeight = Nxt.getBlockchain().getHeight();
   try (Connection con = Db.getConnection();
       PreparedStatement pstmtSelect =
           con.prepareStatement(
               "SELECT additions FROM account_guaranteed_balance "
                   + "WHERE account_id = ? and height = ?");
       PreparedStatement pstmtUpdate =
           con.prepareStatement(
               "MERGE INTO account_guaranteed_balance (account_id, "
                   + " additions, height) KEY (account_id, height) VALUES(?, ?, ?)")) {
     pstmtSelect.setLong(1, this.id);
     pstmtSelect.setInt(2, blockchainHeight);
     try (ResultSet rs = pstmtSelect.executeQuery()) {
       long additions = amountNQT;
       if (rs.next()) {
         additions = Convert.safeAdd(additions, rs.getLong("additions"));
       }
       pstmtUpdate.setLong(1, this.id);
       pstmtUpdate.setLong(2, additions);
       pstmtUpdate.setInt(3, blockchainHeight);
       pstmtUpdate.executeUpdate();
     }
   } catch (SQLException e) {
     throw new RuntimeException(e.toString(), e);
   }
 }
        @Override
        public void run() {

          try {
            try {
              List<Transaction> transactionList = new ArrayList<>();
              int curTime = Convert.getEpochTime();
              for (TransactionImpl transaction : nonBroadcastedTransactions.values()) {
                if (TransactionDb.hasTransaction(transaction.getId())
                    || transaction.getExpiration() < curTime) {
                  nonBroadcastedTransactions.remove(transaction.getId());
                } else if (transaction.getTimestamp() < curTime - 30) {
                  transactionList.add(transaction);
                }
              }

              if (transactionList.size() > 0) {
                Peers.sendToSomePeers(transactionList);
              }

            } catch (Exception e) {
              Logger.logDebugMessage("Error in transaction re-broadcasting thread", e);
            }
          } catch (Throwable t) {
            Logger.logMessage("CRITICAL ERROR. PLEASE REPORT TO THE DEVELOPERS.\n" + t.toString());
            t.printStackTrace();
            System.exit(1);
          }
        }
 @Override
 public Transaction newTransaction(
     short deadline,
     byte[] senderPublicKey,
     Long recipientId,
     long amountNQT,
     long feeNQT,
     String referencedTransactionFullHash,
     Attachment attachment)
     throws NxtException.ValidationException {
   TransactionImpl transaction =
       new TransactionImpl(
           attachment.getTransactionType(),
           Convert.getEpochTime(),
           deadline,
           senderPublicKey,
           recipientId,
           amountNQT,
           feeNQT,
           referencedTransactionFullHash,
           null);
   transaction.setAttachment(attachment);
   transaction.validateAttachment();
   return transaction;
 }
Example #19
0
 void addToForgedBalanceNQT(long amountNQT) {
   if (amountNQT == 0) {
     return;
   }
   this.forgedBalanceNQT = Convert.safeAdd(this.forgedBalanceNQT, amountNQT);
   accountTable.insert(this);
 }
Example #20
0
 private static void checkBalance(long accountId, long confirmed, long unconfirmed) {
   if (confirmed < 0) {
     throw new DoubleSpendingException(
         "Negative balance or quantity for account " + Convert.toUnsignedLong(accountId));
   }
   if (unconfirmed < 0) {
     throw new DoubleSpendingException(
         "Negative unconfirmed balance or quantity for account "
             + Convert.toUnsignedLong(accountId));
   }
   if (unconfirmed > confirmed) {
     throw new DoubleSpendingException(
         "Unconfirmed exceeds confirmed balance or quantity for account "
             + Convert.toUnsignedLong(accountId));
   }
 }
Example #21
0
 public long getGuaranteedBalanceNQT(final int numberOfConfirmations, final int currentHeight) {
   if (numberOfConfirmations >= Nxt.getBlockchain().getHeight()) {
     return 0;
   }
   if (numberOfConfirmations > 2880 || numberOfConfirmations < 0) {
     throw new IllegalArgumentException(
         "Number of required confirmations must be between 0 and " + 2880);
   }
   int height = currentHeight - numberOfConfirmations;
   try (Connection con = Db.getConnection();
       PreparedStatement pstmt =
           con.prepareStatement(
               "SELECT SUM (additions) AS additions "
                   + "FROM account_guaranteed_balance WHERE account_id = ? AND height > ? AND height <= ?")) {
     pstmt.setLong(1, this.id);
     pstmt.setInt(2, height);
     pstmt.setInt(3, currentHeight);
     try (ResultSet rs = pstmt.executeQuery()) {
       if (!rs.next()) {
         return balanceNQT;
       }
       return Math.max(Convert.safeSubtract(balanceNQT, rs.getLong("additions")), 0);
     }
   } catch (SQLException e) {
     throw new RuntimeException(e.toString(), e);
   }
 }
Example #22
0
 // returns true iff:
 // this.publicKey is set to null (in which case this.publicKey also gets set to key)
 // or
 // this.publicKey is already set to an array equal to key
 boolean setOrVerify(byte[] key, int height) {
   if (this.publicKey == null) {
     if (Db.isInTransaction()) {
       this.publicKey = key;
       this.keyHeight = -1;
       accountTable.insert(this);
     }
     return true;
   } else if (Arrays.equals(this.publicKey, key)) {
     return true;
   } else if (this.keyHeight == -1) {
     Logger.logMessage("DUPLICATE KEY!!!");
     Logger.logMessage(
         "Account key for "
             + Convert.toUnsignedLong(id)
             + " was already set to a different one at the same height "
             + ", current height is "
             + height
             + ", rejecting new key");
     return false;
   } else if (this.keyHeight >= height) {
     Logger.logMessage("DUPLICATE KEY!!!");
     if (Db.isInTransaction()) {
       Logger.logMessage(
           "Changing key for account "
               + Convert.toUnsignedLong(id)
               + " at height "
               + height
               + ", was previously set to a different one at height "
               + keyHeight);
       this.publicKey = key;
       this.keyHeight = height;
       accountTable.insert(this);
     }
     return true;
   }
   Logger.logMessage("DUPLICATE KEY!!!");
   Logger.logMessage(
       "Invalid key for account "
           + Convert.toUnsignedLong(id)
           + " at height "
           + height
           + ", was already set to a different one at height "
           + keyHeight);
   return false;
 }
 private void loadPassPhrases() {
   try {
     List<String> passphrases =
         Files.readAllLines(Paths.get("passphrases.txt"), Charset.forName("US-ASCII"));
     for (String ps : passphrases) {
       if (!ps.isEmpty()) {
         byte[] publicKey = Crypto.getPublicKey(ps);
         byte[] publicKeyHash = Crypto.sha256().digest(publicKey);
         Long id = Convert.fullHashToId(publicKeyHash);
         loadedPassPhrases.put(id, ps);
         LOGGER.info("Added key: {" + ps + "} -> {" + Convert.toUnsignedLong(id) + "}");
       }
     }
   } catch (IOException e) {
     LOGGER.info("Warning: no passphrases.txt found");
   }
 }
  @Override
  JSONStreamAware processRequest(HttpServletRequest req) throws NxtException {

    String transactionBytes = Convert.emptyToNull(req.getParameter("transactionBytes"));
    String transactionJSON = Convert.emptyToNull(req.getParameter("transactionJSON"));
    String prunableAttachmentJSON = Convert.emptyToNull(req.getParameter("prunableAttachmentJSON"));

    Transaction transaction =
        ParameterParser.parseTransaction(transactionJSON, transactionBytes, prunableAttachmentJSON)
            .build();
    JSONObject response = JSONData.unconfirmedTransaction(transaction);
    try {
      transaction.validate();
    } catch (NxtException.ValidationException | RuntimeException e) {
      Logger.logDebugMessage(e.getMessage(), e);
      response.put("validate", false);
      JSONData.putException(response, e, "Invalid transaction");
    }
    response.put("verify", transaction.verifySignature());
    return response;
  }
Example #25
0
 void addToAssetAndUnconfirmedAssetBalanceQNT(long assetId, long quantityQNT) {
   if (quantityQNT == 0) {
     return;
   }
   AccountAsset accountAsset;
   accountAsset = accountAssetTable.get(accountAssetDbKeyFactory.newKey(this.id, assetId));
   long assetBalance = accountAsset == null ? 0 : accountAsset.quantityQNT;
   assetBalance = Convert.safeAdd(assetBalance, quantityQNT);
   long unconfirmedAssetBalance = accountAsset == null ? 0 : accountAsset.unconfirmedQuantityQNT;
   unconfirmedAssetBalance = Convert.safeAdd(unconfirmedAssetBalance, quantityQNT);
   if (accountAsset == null) {
     accountAsset = new AccountAsset(this.id, assetId, assetBalance, unconfirmedAssetBalance);
   } else {
     accountAsset.quantityQNT = assetBalance;
     accountAsset.unconfirmedQuantityQNT = unconfirmedAssetBalance;
   }
   accountAsset.save();
   listeners.notify(this, Event.ASSET_BALANCE);
   listeners.notify(this, Event.UNCONFIRMED_ASSET_BALANCE);
   assetListeners.notify(accountAsset, Event.ASSET_BALANCE);
   assetListeners.notify(accountAsset, Event.UNCONFIRMED_ASSET_BALANCE);
 }
Example #26
0
  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);
    try {
      return new Hallmark(hallmarkString, publicKey, signature, host, weight, date, isValid);
    } catch (URISyntaxException e) {
      throw new RuntimeException(e.toString(), e);
    }
  }
  @Override
  JSONStreamAware processRequest(HttpServletRequest req) throws ParameterException {
    String query = Convert.nullToEmpty(req.getParameter("query"));
    int firstIndex = ParameterParser.getFirstIndex(req);
    int lastIndex = ParameterParser.getLastIndex(req);
    boolean includeCounts = !"false".equalsIgnoreCase(req.getParameter("includeCounts"));

    JSONObject response = new JSONObject();
    JSONArray jsonArray = new JSONArray();
    try (DbIterator<Currency> currencies =
        Currency.searchCurrencies(query, firstIndex, lastIndex)) {
      while (currencies.hasNext()) {
        jsonArray.add(JSONData.currency(currencies.next(), includeCounts));
      }
    }
    response.put("currencies", jsonArray);
    return response;
  }
Example #28
0
 void apply(byte[] key, int height) {
   if (!setOrVerify(key, this.creationHeight)) {
     throw new IllegalStateException("Public key mismatch");
   }
   if (this.publicKey == null) {
     throw new IllegalStateException(
         "Public key has not been set for account "
             + Convert.toUnsignedLong(id)
             + " at height "
             + height
             + ", key height is "
             + keyHeight);
   }
   if (this.keyHeight == -1 || this.keyHeight > height) {
     this.keyHeight = height;
     accountTable.insert(this);
   }
 }
Example #29
0
  @Override
  protected JSONStreamAware processRequest(HttpServletRequest req) throws NxtException {

    DigitalGoodsStore.Goods goods = ParameterParser.getGoods(req);
    if (goods.isDelisted()) {
      return UNKNOWN_GOODS;
    }

    int quantity = ParameterParser.getGoodsQuantity(req);
    if (quantity > goods.getQuantity()) {
      return INCORRECT_PURCHASE_QUANTITY;
    }

    long priceNQT = ParameterParser.getPriceNQT(req);
    if (priceNQT != goods.getPriceNQT()) {
      return INCORRECT_PURCHASE_PRICE;
    }

    String deliveryDeadlineString =
        Convert.emptyToNull(req.getParameter("deliveryDeadlineTimestamp"));
    if (deliveryDeadlineString == null) {
      return MISSING_DELIVERY_DEADLINE_TIMESTAMP;
    }
    int deliveryDeadline;
    try {
      deliveryDeadline = Integer.parseInt(deliveryDeadlineString);
      if (deliveryDeadline <= Nxt.getEpochTime()) {
        return INCORRECT_DELIVERY_DEADLINE_TIMESTAMP;
      }
    } catch (NumberFormatException e) {
      return INCORRECT_DELIVERY_DEADLINE_TIMESTAMP;
    }

    Account buyerAccount = ParameterParser.getSenderAccount(req);
    Account sellerAccount = Account.getAccount(goods.getSellerId());

    Attachment attachment =
        new Attachment.DigitalGoodsPurchase(goods.getId(), quantity, priceNQT, deliveryDeadline);
    try {
      return createTransaction(req, buyerAccount, sellerAccount.getId(), 0, attachment);
    } catch (NxtException.InsufficientBalanceException e) {
      return JSONResponses.NOT_ENOUGH_FUNDS;
    }
  }
Example #30
0
 private static String buildLinks(HttpServletRequest req) {
   StringBuilder buf = new StringBuilder();
   String requestTag = Convert.nullToEmpty(req.getParameter("requestTag"));
   buf.append("<li");
   if (requestTag.equals("")) {
     buf.append(" class=\"active\"");
   }
   buf.append("><a href=\"/test\">All</a></li>");
   for (APITag apiTag : APITag.values()) {
     if (requestTags.get(apiTag.name()) != null) {
       buf.append("<li");
       if (requestTag.equals(apiTag.name())) {
         buf.append(" class=\"active\"");
       }
       buf.append("><a href=\"/test?requestTag=").append(apiTag.name()).append("\">");
       buf.append(apiTag.getDisplayName()).append("</a></li>").append(" ");
     }
   }
   return buf.toString();
 }