private void parsePaymentRequest(Protos.PaymentRequest request) throws PaymentProtocolException {
   try {
     if (request == null) throw new PaymentProtocolException("request cannot be null");
     if (request.getPaymentDetailsVersion() != 1)
       throw new PaymentProtocolException.InvalidVersion(
           "Version 1 required. Received version " + request.getPaymentDetailsVersion());
     paymentRequest = request;
     if (!request.hasSerializedPaymentDetails())
       throw new PaymentProtocolException("No PaymentDetails");
     paymentDetails =
         Protos.PaymentDetails.newBuilder()
             .mergeFrom(request.getSerializedPaymentDetails())
             .build();
     if (paymentDetails == null) throw new PaymentProtocolException("Invalid PaymentDetails");
     if (!paymentDetails.hasNetwork()) params = MainNetParams.get();
     else params = NetworkParameters.fromPmtProtocolID(paymentDetails.getNetwork());
     if (params == null)
       throw new PaymentProtocolException.InvalidNetwork(
           "Invalid network " + paymentDetails.getNetwork());
     if (paymentDetails.getOutputsCount() < 1)
       throw new PaymentProtocolException.InvalidOutputs("No outputs");
     for (Protos.Output output : paymentDetails.getOutputsList()) {
       if (output.hasAmount()) totalValue = totalValue.add(Coin.valueOf(output.getAmount()));
     }
     // This won't ever happen in practice. It would only happen if the user provided outputs
     // that are obviously invalid. Still, we don't want to silently overflow.
     if (params.hasMaxMoney() && totalValue.compareTo(params.getMaxMoney()) > 0)
       throw new PaymentProtocolException.InvalidOutputs("The outputs are way too big.");
   } catch (InvalidProtocolBufferException e) {
     throw new PaymentProtocolException(e);
   }
 }
  public void processChange(int change) {
    if (change == 0) {
      return;
    } else {
      int availableQty = getQuantity();
      Coin c = (Coin) getContent();
      int denoCoin = c.getValue();
      int neededQty = change / denoCoin;
      if ((change >= denoCoin) && (availableQty > 0)) {
        if (availableQty >= neededQty) {
          availableQty -= neededQty;
          setHandledAmount(neededQty);
          change -= neededQty * denoCoin;
        } else if (availableQty < neededQty) {
          setHandledAmount(availableQty);
          change -= availableQty * denoCoin;
          availableQty = 0;
        }
        setQuantity(availableQty);
        System.out.println("CHANGE GIVEN :- " + denoCoin);
      }

      if ((successor == null) && (change > 0)) {
        System.out.println("Not enough coin to dispense");
      } else successor.processChange(change);
      return;
    } // end of if
  }
Example #3
0
  /** @see com.anji.roshambo.RoshamboPlayer#nextMove() */
  public int nextMove() {
    int nextmove;
    // sets unbeatable flag if no pattern is found
    unbeatable = true;
    for (int i = 0; i < nrofpatterns; i++) {
      if ((patternscore(i) > movenr / 5) || (patternscore(i) > historylength / 5)) {
        unbeatable = false;
        break;
      }
    }
    // determine the next move
    if (movenr < 3 || unbeatable) nextmove = Coin.flip();
    else {
      int best_p = bestpattern();
      p_chosen[best_p]++;
      nextmove = prediction(best_p);
    }
    // check op mogelijke illegale zet
    if ((nextmove > 2) || (nextmove < 0)) {
      nextmove = Coin.flip();
    }
    // store move
    history[MINE][movenr] = nextmove;

    if (!unbeatable) bp++;
    else ubp++;
    return nextmove;
  }
Example #4
0
 private int calculateCoins() {
   int sum = 0;
   if (this.coins == null || this.coins.size() == 0) return sum;
   for (Coin c : this.coins) {
     sum += c.getValue();
   }
   return sum;
 }
 /**
  * Creates the initial multisig contract and incomplete refund transaction which can be requested
  * at the appropriate time using {@link PaymentChannelClientState#getIncompleteRefundTransaction}
  * and {@link PaymentChannelClientState#getMultisigContract()}. The way the contract is crafted
  * can be adjusted by overriding {@link
  * PaymentChannelClientState#editContractSendRequest(com.google.bitcoin.core.Wallet.SendRequest)}.
  * By default unconfirmed coins are allowed to be used, as for micropayments the risk should be
  * relatively low.
  *
  * @throws ValueOutOfRangeException if the value being used is too small to be accepted by the
  *     network
  * @throws InsufficientMoneyException if the wallet doesn't contain enough balance to initiate
  */
 public synchronized void initiate() throws ValueOutOfRangeException, InsufficientMoneyException {
   final NetworkParameters params = wallet.getParams();
   Transaction template = new Transaction(params);
   // We always place the client key before the server key because, if either side wants some
   // privacy, they can
   // use a fresh key for the the multisig contract and nowhere else
   List<ECKey> keys = Lists.newArrayList(myKey, serverMultisigKey);
   // There is also probably a change output, but we don't bother shuffling them as it's obvious
   // from the
   // format which one is the change. If we start obfuscating the change output better in future
   // this may
   // be worth revisiting.
   TransactionOutput multisigOutput =
       template.addOutput(totalValue, ScriptBuilder.createMultiSigOutputScript(2, keys));
   if (multisigOutput.getMinNonDustValue().compareTo(totalValue) > 0)
     throw new ValueOutOfRangeException("totalValue too small to use");
   Wallet.SendRequest req = Wallet.SendRequest.forTx(template);
   req.coinSelector = AllowUnconfirmedCoinSelector.get();
   editContractSendRequest(req);
   req.shuffleOutputs = false; // TODO: Fix things so shuffling is usable.
   wallet.completeTx(req);
   Coin multisigFee = req.tx.getFee();
   multisigContract = req.tx;
   // Build a refund transaction that protects us in the case of a bad server that's just trying to
   // cause havoc
   // by locking up peoples money (perhaps as a precursor to a ransom attempt). We time lock it so
   // the server
   // has an assurance that we cannot take back our money by claiming a refund before the channel
   // closes - this
   // relies on the fact that since Bitcoin 0.8 time locked transactions are non-final. This will
   // need to change
   // in future as it breaks the intended design of timelocking/tx replacement, but for now it
   // simplifies this
   // specific protocol somewhat.
   refundTx = new Transaction(params);
   refundTx
       .addInput(multisigOutput)
       .setSequenceNumber(0); // Allow replacement when it's eventually reactivated.
   refundTx.setLockTime(expiryTime);
   if (totalValue.compareTo(Coin.CENT) < 0) {
     // Must pay min fee.
     final Coin valueAfterFee = totalValue.subtract(Transaction.REFERENCE_DEFAULT_MIN_TX_FEE);
     if (Transaction.MIN_NONDUST_OUTPUT.compareTo(valueAfterFee) > 0)
       throw new ValueOutOfRangeException("totalValue too small to use");
     refundTx.addOutput(valueAfterFee, myKey.toAddress(params));
     refundFees = multisigFee.add(Transaction.REFERENCE_DEFAULT_MIN_TX_FEE);
   } else {
     refundTx.addOutput(totalValue, myKey.toAddress(params));
     refundFees = multisigFee;
   }
   refundTx.getConfidence().setSource(TransactionConfidence.Source.SELF);
   log.info(
       "initiated channel with multi-sig contract {}, refund {}",
       multisigContract.getHashAsString(),
       refundTx.getHashAsString());
   state = State.INITIATED;
   // Client should now call getIncompleteRefundTransaction() and send it to the server.
 }
 // Create a payment transaction with valueToMe going back to us
 private synchronized Wallet.SendRequest makeUnsignedChannelContract(Coin valueToMe) {
   Transaction tx = new Transaction(wallet.getParams());
   if (!totalValue.subtract(valueToMe).equals(Coin.ZERO)) {
     clientOutput.setValue(totalValue.subtract(valueToMe));
     tx.addOutput(clientOutput);
   }
   tx.addInput(multisigContract.getOutput(0));
   return Wallet.SendRequest.forTx(tx);
 }
Example #7
0
 private List<Coin> refundCoins(int total) {
   List<Coin> returnCoins = new ArrayList<Coin>();
   for (Coin c : Coin.LARGETOSMALL) {
     int numCoins = total / c.getValue();
     for (int i = 0; i < numCoins; i++) {
       returnCoins.add(c);
     }
     total = total % c.getValue();
   }
   return returnCoins;
 }
Example #8
0
 private void validate(List<Coin> coins) {
   this.invalidCoins = new ArrayList<Coin>();
   this.coins = new ArrayList<Coin>();
   for (Coin coin : coins) {
     if (coin.isValid()) {
       this.coins.add(coin);
     } else {
       this.invalidCoins.add(coin);
     }
   }
 }
 // -------------------------------------------------------------------------------------------------------------------------------------------------------
 // Drawing
 public void drawCoin(Graphics g) {
   // draws the coins
   for (Coin i : coinList) {
     g.drawImage(
         i.getPics().get(i.getCounter()), i.getX(), i.getY(), i.getWidth(), i.getHeight(), null);
     i.count();
     i.setDirection();
   }
 }
 /**
  * Returns the outstanding amount of money sent back to us for all channels to this server added
  * together.
  */
 public Coin getBalanceForServer(Sha256Hash id) {
   Coin balance = Coin.ZERO;
   lock.lock();
   try {
     Set<StoredClientChannel> setChannels = mapChannels.get(id);
     for (StoredClientChannel channel : setChannels) {
       synchronized (channel) {
         if (channel.close != null) continue;
         balance = balance.add(channel.valueToMe);
       }
     }
     return balance;
   } finally {
     lock.unlock();
   }
 }
Example #11
0
 /**
  * Returns the value of this output. This is the amount of currency that the destination address
  * receives.
  */
 public Coin getValue() {
   maybeParse();
   try {
     return Coin.valueOf(value);
   } catch (IllegalArgumentException e) {
     throw new IllegalStateException(e.getMessage(), e);
   }
 }
Example #12
0
 public TransactionOutput(
     NetworkParameters params, @Nullable Transaction parent, Coin value, byte[] scriptBytes) {
   super(params);
   // Negative values obviously make no sense, except for -1 which is used as a sentinel value when
   // calculating
   // SIGHASH_SINGLE signatures, so unfortunately we have to allow that here.
   checkArgument(
       value.signum() >= 0 || value.equals(Coin.NEGATIVE_SATOSHI), "Negative values not allowed");
   checkArgument(
       value.compareTo(NetworkParameters.MAX_MONEY) < 0,
       "Values larger than MAX_MONEY not allowed");
   this.value = value.value;
   this.scriptBytes = scriptBytes;
   parentTransaction = parent;
   availableForSpending = true;
   length = 8 + VarInt.sizeOf(scriptBytes.length) + scriptBytes.length;
 }
 /** Returns a {@link Wallet.SendRequest} suitable for broadcasting to the network. */
 public Wallet.SendRequest getSendRequest() {
   Transaction tx = new Transaction(params);
   for (Protos.Output output : paymentDetails.getOutputsList())
     tx.addOutput(
         new TransactionOutput(
             params, tx, Coin.valueOf(output.getAmount()), output.getScript().toByteArray()));
   return Wallet.SendRequest.forTx(tx).fromPaymentDetails(paymentDetails);
 }
 public void scrollCoins() {
   for (Coin i : coinList) {
     i.setY(i.getY() + (int) (player1.getVelocity() * 0.3));
     i.setYPos(i.getYPos() + (int) (player1.getVelocity() * 0.3));
     i.setYMax(i.getYMax() + (int) (player1.getVelocity() * 0.3));
   }
 }
 /**
  * Updates the outputs on the payment contract transaction and re-signs it. The state must be
  * READY in order to call this method. The signature that is returned should be sent to the server
  * so it has the ability to broadcast the best seen payment when the channel closes or times out.
  *
  * <p>The returned signature is over the payment transaction, which we never have a valid copy of
  * and thus there is no accessor for it on this object.
  *
  * <p>To spend the whole channel increment by {@link PaymentChannelClientState#getTotalValue()} -
  * {@link PaymentChannelClientState#getValueRefunded()}
  *
  * @param size How many satoshis to increment the payment by (note: not the new total).
  * @throws ValueOutOfRangeException If size is negative or the channel does not have sufficient
  *     money in it to complete this payment.
  */
 public synchronized IncrementedPayment incrementPaymentBy(Coin size)
     throws ValueOutOfRangeException {
   checkState(state == State.READY);
   checkNotExpired();
   checkNotNull(size); // Validity of size will be checked by makeUnsignedChannelContract.
   if (size.signum() < 0) throw new ValueOutOfRangeException("Tried to decrement payment");
   Coin newValueToMe = valueToMe.subtract(size);
   if (newValueToMe.compareTo(Transaction.MIN_NONDUST_OUTPUT) < 0 && newValueToMe.signum() > 0) {
     log.info(
         "New value being sent back as change was smaller than minimum nondust output, sending all");
     size = valueToMe;
     newValueToMe = Coin.ZERO;
   }
   if (newValueToMe.signum() < 0)
     throw new ValueOutOfRangeException(
         "Channel has too little money to pay " + size + " satoshis");
   Transaction tx = makeUnsignedChannelContract(newValueToMe);
   log.info("Signing new payment tx {}", tx);
   Transaction.SigHash mode;
   // If we spent all the money we put into this channel, we (by definition) don't care what the
   // outputs are, so
   // we sign with SIGHASH_NONE to let the server do what it wants.
   if (newValueToMe.equals(Coin.ZERO)) mode = Transaction.SigHash.NONE;
   else mode = Transaction.SigHash.SINGLE;
   TransactionSignature sig = tx.calculateSignature(0, myKey, multisigScript, mode, true);
   valueToMe = newValueToMe;
   updateChannelInWallet();
   IncrementedPayment payment = new IncrementedPayment();
   payment.signature = sig;
   payment.amount = size;
   return payment;
 }
  public static void main(String[] args) {
    final int FLIPS = 1000;
    int heads = 0;
    int tails = 0;

    Coin myCoin = new Coin();

    for (int count = 1; count <= FLIPS; count++) {
      myCoin.flip();

      if (myCoin.isHeads()) heads++;
      else tails++;
    }

    System.out.println("Number of flips: " + FLIPS);
    System.out.println("Number of heads: " + heads);
    System.out.println("Number of tails: " + tails);
  }
 /** Returns the outputs of the payment request. */
 public List<PaymentProtocol.Output> getOutputs() {
   List<PaymentProtocol.Output> outputs =
       new ArrayList<PaymentProtocol.Output>(paymentDetails.getOutputsCount());
   for (Protos.Output output : paymentDetails.getOutputsList()) {
     Coin amount = output.hasAmount() ? Coin.valueOf(output.getAmount()) : null;
     outputs.add(new PaymentProtocol.Output(amount, output.getScript().toByteArray()));
   }
   return outputs;
 }
Example #18
0
  public static void main(String[] args) throws Exception {
    Scanner in = new Scanner(System.in);
    System.out.print("Enter Product Name: ");
    String productName = in.next();
    System.out.print("Enter Product value: ");
    int productValue = in.nextInt();

    if (StringUtils.isEmpty(productName) || productValue <= 0) {
      System.out.println("invalid product --->");
      return;
    }
    Product p = new Product(productName, productValue);

    List<Coin> coins = new ArrayList<Coin>();
    int sum = 0;
    while (true) {
      System.out.print("Enter Coin Name or type exit: ");
      String coinName = in.next().toLowerCase();
      if (coinName.equalsIgnoreCase("exit")) {
        break;
      }
      System.out.print("Enter Coin value: ");
      int coinValue = in.nextInt();
      coins.add(new Coin(coinName, coinValue));
    }
    try {

      Vending v = new Vending();
      v.acceptCoins(coins);
      List<Coin> invalids = v.getInvalidCoins();
      if (invalids.size() > 0) {
        System.out.println("invalid coins:--->");
        for (Coin c : invalids) System.out.println(c.getName());
      }
      System.out.println("Product:---------------->" + v.Vend(p));
      List<Coin> refunds = v.getRefundCoins();
      if (refunds.size() > 0) {
        System.out.println("refund Coins:--->");
        for (Coin c : refunds) System.out.println(c.getName());
      }
    } catch (Exception ex) {
      System.out.println(ex.getMessage());
    }
  }
Example #19
0
 public void takeCoin() {
   if (findSelectedObject() instanceof Pirate && ((Pirate) findSelectedObject()).isOn_plane()) {
     for (Coin O : GameData.Coins) {
       if (O.x_on_map == findSelectedObject().x_on_map
           && O.y_on_map == findSelectedObject().y_on_map
           && O.fields_left == findSelectedObject().fields_left) {
         O.takeOrPut();
       }
     }
   } else {
     for (Coin O : GameData.Coins) {
       if (O.x_on_map == findSelectedObject().x_on_map
           && O.y_on_map == findSelectedObject().y_on_map
           && O.fields_left == findSelectedObject().fields_left) {
         O.takeOrPut();
         break;
       }
     }
   }
 }
 @Override
 public void deserializeWalletExtension(Wallet containingWallet, byte[] data) throws Exception {
   lock.lock();
   try {
     checkState(this.containingWallet == null || this.containingWallet == containingWallet);
     this.containingWallet = containingWallet;
     NetworkParameters params = containingWallet.getParams();
     ClientState.StoredClientPaymentChannels states =
         ClientState.StoredClientPaymentChannels.parseFrom(data);
     for (ClientState.StoredClientPaymentChannel storedState : states.getChannelsList()) {
       Transaction refundTransaction =
           params
               .getDefaultSerializer()
               .makeTransaction(storedState.getRefundTransaction().toByteArray());
       refundTransaction.getConfidence().setSource(TransactionConfidence.Source.SELF);
       ECKey myKey =
           (storedState.getMyKey().isEmpty())
               ? containingWallet.findKeyFromPubKey(storedState.getMyPublicKey().toByteArray())
               : ECKey.fromPrivate(storedState.getMyKey().toByteArray());
       StoredClientChannel channel =
           new StoredClientChannel(
               Sha256Hash.wrap(storedState.getId().toByteArray()),
               params
                   .getDefaultSerializer()
                   .makeTransaction(storedState.getContractTransaction().toByteArray()),
               refundTransaction,
               myKey,
               Coin.valueOf(storedState.getValueToMe()),
               Coin.valueOf(storedState.getRefundFees()),
               false);
       if (storedState.hasCloseTransactionHash()) {
         Sha256Hash closeTxHash =
             Sha256Hash.wrap(storedState.getCloseTransactionHash().toByteArray());
         channel.close = containingWallet.getTransaction(closeTxHash);
       }
       putChannel(channel, false);
     }
   } finally {
     lock.unlock();
   }
 }
 /**
  * Creates a state object for a payment channel client. It is expected that you be ready to {@link
  * PaymentChannelClientState#initiate()} after construction (to avoid creating objects for
  * channels which are not going to finish opening) and thus some parameters provided here are only
  * used in {@link PaymentChannelClientState#initiate()} to create the Multisig contract and refund
  * transaction.
  *
  * @param wallet a wallet that contains at least the specified amount of value.
  * @param myKey a freshly generated private key for this channel.
  * @param serverMultisigKey a public key retrieved from the server used for the initial multisig
  *     contract
  * @param value how many satoshis to put into this contract. If the channel reaches this limit, it
  *     must be closed. It is suggested you use at least {@link Utils#CENT} to avoid paying fees if
  *     you need to spend the refund transaction
  * @param expiryTimeInSeconds At what point (UNIX timestamp +/- a few hours) the channel will
  *     expire
  * @throws VerificationException If either myKey's pubkey or serverMultisigKey's pubkey are
  *     non-canonical (ie invalid)
  */
 public PaymentChannelClientState(
     Wallet wallet, ECKey myKey, ECKey serverMultisigKey, Coin value, long expiryTimeInSeconds)
     throws VerificationException {
   checkArgument(value.signum() > 0);
   this.wallet = checkNotNull(wallet);
   initWalletListeners();
   this.serverMultisigKey = checkNotNull(serverMultisigKey);
   this.myKey = checkNotNull(myKey);
   this.valueToMe = this.totalValue = checkNotNull(value);
   this.expiryTime = expiryTimeInSeconds;
   this.state = State.NEW;
 }
  public void checkPupCollision() {
    // pretty much the same thing as before, however it alsoe does the powerup effects
    for (Powerup p : pupList) {
      if (p.getOnScreen()) { // can be removed later on
        if (p.checkCollision(player1)) {
          pupRemove.add(p);
          player1.setPower(p.getType());
          player1.setVelo(50);
        }
      } else {
        pupRemove.add(p);
      }
    }
    if (player1.getPower().equals("Lucky")) { // changes everything to stars
      for (Coin c : coinList) {
        starList.add(new Star(c.getX(), c.getY(), 2));
        cRemove.add(c);
      }
      for (Box b : boxList) {
        starList.add(new Star(b.getX(), b.getY(), 2));
        bRemove.add(b);
      }
      for (Enemy e : enemyList) {
        starList.add(new Star(e.getX(), e.getY(), 2));
        eRemove.add(e);
      }
    } else if (player1.getPower().equals("Magnet")) { // moves the coins towards the player
      for (Coin c : coinList) {
        c.moveTowards(player1);
      }
    } else { // else do nothing

    }
    for (Powerup p : pupRemove) {
      poofList.add(new Poof(p.getX(), p.getY(), 2));
      pupList.remove(p);
    }
    pupRemove = new ArrayList<Powerup>();
  }
Example #23
0
 /**
  * Create a standard pay to address output for usage in {@link #createPaymentRequest} and {@link
  * #createPaymentMessage}.
  *
  * @param amount amount to pay, or null
  * @param address address to pay to
  * @return output
  */
 public static Protos.Output createPayToAddressOutput(@Nullable Coin amount, Address address) {
   Protos.Output.Builder output = Protos.Output.newBuilder();
   if (amount != null) {
     final NetworkParameters params = address.getParameters();
     if (params.hasMaxMoney() && amount.compareTo(params.getMaxMoney()) > 0)
       throw new IllegalArgumentException("Amount too big: " + amount);
     output.setAmount(amount.value);
   } else {
     output.setAmount(0);
   }
   output.setScript(ByteString.copyFrom(ScriptBuilder.createOutputScript(address).getProgram()));
   return output.build();
 }
Example #24
0
  public void save(Button.ClickEvent event) {
    try {
      formFieldBindings.commit();

      service.saveAsNewCoin(coin, crawlerResult);

      String msg = String.format("Saved '%s'.", coin.getName());
      Notification.show(msg, Notification.Type.TRAY_NOTIFICATION);
      parentTable.refreshResults();
    } catch (FieldGroup.CommitException e) {
      e.printStackTrace();
    }
  }
 @Override
 public CoinSelection select(Coin target, List<TransactionOutput> candidates) {
   try {
     LinkedList<TransactionOutput> gathered = Lists.newLinkedList();
     Coin valueGathered = Coin.ZERO;
     for (TransactionOutput output : candidates) {
       if (ignorePending && !isConfirmed(output)) continue;
       // Find the key that controls output, assuming it's a regular pay-to-pubkey or
       // pay-to-address output.
       // We ignore any other kind of exotic output on the assumption we can't spend it ourselves.
       final Script scriptPubKey = output.getScriptPubKey();
       ECKey controllingKey;
       if (scriptPubKey.isSentToRawPubKey()) {
         controllingKey = wallet.findKeyFromPubKey(scriptPubKey.getPubKey());
       } else if (scriptPubKey.isSentToAddress()) {
         controllingKey = wallet.findKeyFromPubHash(scriptPubKey.getPubKeyHash());
       } else {
         log.info("Skipping tx output {} because it's not of simple form.", output);
         continue;
       }
       checkNotNull(
           controllingKey, "Coin selector given output as candidate for which we lack the key");
       if (controllingKey.getCreationTimeSeconds() >= unixTimeSeconds) continue;
       // It's older than the cutoff time so select.
       valueGathered = valueGathered.add(output.getValue());
       gathered.push(output);
       if (gathered.size() >= MAX_SIMULTANEOUS_INPUTS) {
         log.warn(
             "Reached {} inputs, going further would yield a tx that is too large, stopping here.",
             gathered.size());
         break;
       }
     }
     return new CoinSelection(valueGathered, gathered);
   } catch (ScriptException e) {
     throw new RuntimeException(
         e); // We should never have problems understanding scripts in our wallet.
   }
 }
Example #26
0
  public void edit(CrawlerResult crawlerResult) {
    this.crawlerResult = crawlerResult;
    if (crawlerResult != null) {
      coin = new Coin();
      coin.setName(crawlerResult.getName());
      coin.setNominal(NameUtils.parseNominal(crawlerResult.getName()));

      CoinVariant variant = new CoinVariant();
      //        variant.setReleaseDate(LocalDate.now());
      variant.setVariant(NameUtils.parseVariant(crawlerResult.getVariant()));
      if (variant.getVariant() == Variant.UNKNOWN) {
        variant.setVariant(NameUtils.parseVariant(crawlerResult.getName()));
      }
      coin.addVariant(variant);
      variantField.setValue(variant.getVariant());

      CoinVariantHistory history = new CoinVariantHistory();
      history.setDate(crawlerResult.getProcessed());
      history.setSource(crawlerResult.getSource().toString());
      Money price = PriceUtils.parse(crawlerResult.getPrice());
      if (price == null) {
        price = Money.euros(0.0);
      }
      history.setPrice(price);
      variant.addHistory(history);
      priceField.setValue(price.toString());

      formFieldBindings = BeanFieldGroup.bindFieldsBuffered(coin, this);

      sourceLink.setCaption(LinkUtils.getSourceUrl(crawlerResult));
      sourceLink.setResource(new ExternalResource(LinkUtils.getUrl(crawlerResult)));
      sourceLink.setTargetName("_blank");

      name.focus();
    }
    setVisible(crawlerResult != null);
  }
 public void checkCoinCollision() {
   for (Coin c : coinList) {
     if (c.getOnScreen()) { // check if the coin is on the screen
       if (c.checkCollision(
           c.getPics().get(c.getCounter()), player1)) { // if the player collides with the coin
         cRemove.add(c); // remove the coin
         player1.setVelo(50); // set the velocity so the player moves up
         player1.setDown(false); // set the down false (players moving up)
         coins += c.getValue(); // check the coins collected
         score += c.getPoints(); // get the score
         if (musicOn) {
           coinSound.play(); // play the sound
         }
       }
     } else {
       cRemove.add(c); // remove the coin
     }
   }
   for (Coin c : cRemove) {
     poofList.add(new Poof(c.getX(), c.getY(), 0));
     coinList.remove(c);
   }
   cRemove = new ArrayList<Coin>();
 }
Example #28
0
 private int detectcopy(int who) {
   if (movenr < 2) return Coin.flip();
   int length = 10;
   if (movenr < 5) length = movenr - 1;
   if (movenr < 10) length = movenr - 3;
   int other = (who + 1) % 2;
   for (int i = 1; i < 5; i++) {
     int a = historySearch(who, other, other, length, length, i, i, 1, 0, 1);
     if (a != -3) return a;
     int b = historySearch(who, other, other, length, length, i, i, 1, 1, 1);
     if (b != -3) return b;
     int c = historySearch(who, other, other, length, length, i, i, 1, 2, 1);
     if (c != -3) return c;
   }
   return -3;
 }
Example #29
0
 /**
  * Gets the minimum value for a txout of this size to be considered non-dust by a reference client
  * (and thus relayed). See: CTxOut::IsDust() in the reference client. The assumption is that any
  * output that would consume more than a third of its value in fees is not something the Bitcoin
  * system wants to deal with right now, so we call them "dust outputs" and they're made non
  * standard. The choice of one third is somewhat arbitrary and may change in future.
  *
  * <p>You probably should use {@link
  * com.google.bitcoin.core.TransactionOutput#getMinNonDustValue()} which uses a safe fee-per-kb by
  * default.
  *
  * @param feePerKbRequired The fee required per kilobyte. Note that this is the same as the
  *     reference client's -minrelaytxfee * 3 If you want a safe default, use {@link
  *     Transaction#REFERENCE_DEFAULT_MIN_TX_FEE}*3
  */
 public Coin getMinNonDustValue(Coin feePerKbRequired) {
   // A typical output is 33 bytes (pubkey hash + opcodes) and requires an input of 148 bytes to
   // spend so we add
   // that together to find out the total amount of data used to transfer this amount of value.
   // Note that this
   // formula is wrong for anything that's not a pay-to-address output, unfortunately, we must
   // follow the reference
   // clients wrongness in order to ensure we're considered standard. A better formula would either
   // estimate the
   // size of data needed to satisfy all different script types, or just hard code 33 below.
   final long size = this.bitcoinSerialize().length + 148;
   Coin[] nonDustAndRemainder = feePerKbRequired.multiply(size).divideAndRemainder(1000);
   return nonDustAndRemainder[1].equals(Coin.ZERO)
       ? nonDustAndRemainder[0]
       : nonDustAndRemainder[0].add(Coin.SATOSHI);
 }
Example #30
0
  @Test
  public void testReceiveCoinbaseTransaction() throws Exception {
    // Block 169482 (hash 0000000000000756935f1ee9d5987857b604046f846d3df56d024cdb5f368665)
    // contains coinbase transactions that are mining pool shares.
    // The private key MINERS_KEY is used to check transactions are received by a wallet correctly.

    // The address for this private key is 1GqtGtn4fctXuKxsVzRPSLmYWN1YioLi9y.
    final String MINING_PRIVATE_KEY = "5JDxPrBRghF1EvSBjDigywqfmAjpHPmTJxYtQTYJxJRHLLQA4mG";

    final long BLOCK_NONCE = 3973947400L;
    final Coin BALANCE_AFTER_BLOCK = Coin.valueOf(22223642);
    final NetworkParameters PARAMS = MainNetParams.get();

    Block block169482 =
        PARAMS
            .getDefaultSerializer()
            .makeBlock(ByteStreams.toByteArray(getClass().getResourceAsStream("block169482.dat")));

    // Check block.
    assertNotNull(block169482);
    block169482.verify(169482, EnumSet.noneOf(Block.VerifyFlag.class));
    assertEquals(BLOCK_NONCE, block169482.getNonce());

    StoredBlock storedBlock =
        new StoredBlock(block169482, BigInteger.ONE, 169482); // Nonsense work - not used in test.

    // Create a wallet contain the miner's key that receives a spend from a coinbase.
    ECKey miningKey = DumpedPrivateKey.fromBase58(PARAMS, MINING_PRIVATE_KEY).getKey();
    assertNotNull(miningKey);
    Context context = new Context(PARAMS);
    Wallet wallet = new Wallet(context);
    wallet.importKey(miningKey);

    // Initial balance should be zero by construction.
    assertEquals(Coin.ZERO, wallet.getBalance());

    // Give the wallet the first transaction in the block - this is the coinbase tx.
    List<Transaction> transactions = block169482.getTransactions();
    assertNotNull(transactions);
    wallet.receiveFromBlock(transactions.get(0), storedBlock, NewBlockType.BEST_CHAIN, 0);

    // Coinbase transaction should have been received successfully but be unavailable to spend (too
    // young).
    assertEquals(BALANCE_AFTER_BLOCK, wallet.getBalance(BalanceType.ESTIMATED));
    assertEquals(Coin.ZERO, wallet.getBalance(BalanceType.AVAILABLE));
  }