public boolean sendCoinsMulti(Map<Address, Double> toSend) {
    Transaction tx = new Transaction(Craftcoinish.network);
    double totalSend = 0.0;

    for (Entry<Address, Double> current : toSend.entrySet()) {
      totalSend += current.getValue() / Craftcoinish.mult;
      tx.addOutput(Craftcoinish.econ.inGameToBitcoin(current.getValue()), current.getKey());
    }

    if (totalSend < 0.01) {
      return false;
    }

    Wallet.SendRequest request = Wallet.SendRequest.forTx(tx);

    if (!localWallet.completeTx(request)) {
      return false;
    } else {
      localPeerGroup.broadcastTransaction(request.tx);
      try {
        localWallet.commitTx(request.tx);
      } catch (VerificationException e) {
        e.printStackTrace();
      }
      return true;
    }
  }
Example #2
0
 private static void send(PaymentSession session) {
   try {
     System.out.println("Payment Request");
     System.out.println("Amount: " + session.getValue().doubleValue() / 100000 + "mDOGE");
     System.out.println("Date: " + session.getDate());
     System.out.println("Memo: " + session.getMemo());
     if (session.pkiVerificationData != null) {
       System.out.println("Pki-Verified Name: " + session.pkiVerificationData.name);
       if (session.pkiVerificationData.orgName != null)
         System.out.println("Pki-Verified Org: " + session.pkiVerificationData.orgName);
       System.out.println(
           "PKI data verified by: " + session.pkiVerificationData.rootAuthorityName);
     }
     final Wallet.SendRequest req = session.getSendRequest();
     if (password != null) {
       if (!wallet.checkPassword(password)) {
         System.err.println("Password is incorrect.");
         return;
       }
       req.aesKey = wallet.getKeyCrypter().deriveKey(password);
     }
     wallet.completeTx(req); // may throw InsufficientMoneyException.
     if (options.has("offline")) {
       wallet.commitTx(req.tx);
       return;
     }
     setup();
     // No refund address specified, no user-specified memo field.
     ListenableFuture<PaymentSession.Ack> future =
         session.sendPayment(ImmutableList.of(req.tx), null, null);
     if (future == null) {
       // No payment_url for submission so, broadcast and wait.
       peers.startAndWait();
       peers.broadcastTransaction(req.tx).get();
     } else {
       PaymentSession.Ack ack = future.get();
       wallet.commitTx(req.tx);
       System.out.println("Memo from server: " + ack.getMemo());
     }
   } catch (PaymentRequestException e) {
     System.err.println("Failed to send payment " + e.getMessage());
     System.exit(1);
   } catch (VerificationException e) {
     System.err.println("Failed to send payment " + e.getMessage());
     System.exit(1);
   } catch (ExecutionException e) {
     System.err.println("Failed to send payment " + e.getMessage());
     System.exit(1);
   } catch (IOException e) {
     System.err.println("Invalid payment " + e.getMessage());
     System.exit(1);
   } catch (InterruptedException e1) {
     // Ignore.
   } catch (InsufficientMoneyException e) {
     System.err.println(
         "Insufficient funds: have " + Utils.bitcoinValueToFriendlyString(wallet.getBalance()));
   } catch (BlockStoreException e) {
     throw new RuntimeException(e);
   }
 }
  /** Test that if the block height is missing from coinbase of a version 2 block, it's rejected. */
  @Test
  public void missingHeightFromCoinbase() throws Exception {
    final int UNDOABLE_BLOCKS_STORED = params.getMajorityEnforceBlockUpgrade() + 1;
    store = createStore(params, UNDOABLE_BLOCKS_STORED);
    try {
      chain = new FullPrunedBlockChain(params, store);
      ECKey outKey = new ECKey();
      int height = 1;
      Block chainHead = params.getGenesisBlock();

      // Build some blocks on genesis block to create a spendable output.

      // Put in just enough v1 blocks to stop the v2 blocks from forming a majority
      for (height = 1;
          height <= (params.getMajorityWindow() - params.getMajorityEnforceBlockUpgrade());
          height++) {
        chainHead =
            chainHead.createNextBlockWithCoinbase(
                Block.BLOCK_VERSION_GENESIS, outKey.getPubKey(), height);
        chain.add(chainHead);
      }

      // Fill the rest of the window in with v2 blocks
      for (; height < params.getMajorityWindow(); height++) {
        chainHead =
            chainHead.createNextBlockWithCoinbase(
                Block.BLOCK_VERSION_BIP34, outKey.getPubKey(), height);
        chain.add(chainHead);
      }
      // Throw a broken v2 block in before we have a supermajority to enable
      // enforcement, which should validate as-is
      chainHead =
          chainHead.createNextBlockWithCoinbase(
              Block.BLOCK_VERSION_BIP34, outKey.getPubKey(), height * 2);
      chain.add(chainHead);
      height++;

      // Trying to add a broken v2 block should now result in rejection as
      // we have a v2 supermajority
      thrown.expect(VerificationException.CoinbaseHeightMismatch.class);
      chainHead =
          chainHead.createNextBlockWithCoinbase(
              Block.BLOCK_VERSION_BIP34, outKey.getPubKey(), height * 2);
      chain.add(chainHead);
    } catch (final VerificationException ex) {
      throw (Exception) ex.getCause();
    } finally {
      try {
        store.close();
      } catch (Exception e) {
        // Catch and drop any exception so a break mid-test doesn't result
        // in a new exception being thrown and the original lost
      }
    }
  }
 private void multisigContractPropogated(
     Protos.ProvideContract providedContract, Sha256Hash contractHash) {
   lock.lock();
   try {
     if (!connectionOpen || channelSettling) return;
     state.storeChannelInWallet(PaymentChannelServer.this);
     try {
       receiveUpdatePaymentMessage(providedContract.getInitialPayment(), false /* no ack msg */);
     } catch (VerificationException e) {
       log.error("Initial payment failed to verify", e);
       error(
           e.getMessage(),
           Protos.Error.ErrorCode.BAD_TRANSACTION,
           CloseReason.REMOTE_SENT_INVALID_MESSAGE);
       return;
     } catch (ValueOutOfRangeException e) {
       log.error("Initial payment value was out of range", e);
       error(
           e.getMessage(),
           Protos.Error.ErrorCode.BAD_TRANSACTION,
           CloseReason.REMOTE_SENT_INVALID_MESSAGE);
       return;
     } catch (InsufficientMoneyException e) {
       // This shouldn't happen because the server shouldn't allow itself to get into this
       // situation in the
       // first place, by specifying a min up front payment.
       log.error(
           "Tried to settle channel and could not afford the fees whilst updating payment", e);
       error(
           e.getMessage(),
           Protos.Error.ErrorCode.BAD_TRANSACTION,
           CloseReason.REMOTE_SENT_INVALID_MESSAGE);
       return;
     }
     conn.sendToClient(
         Protos.TwoWayChannelMessage.newBuilder()
             .setType(Protos.TwoWayChannelMessage.MessageType.CHANNEL_OPEN)
             .build());
     step = InitStep.CHANNEL_OPEN;
     conn.channelOpen(contractHash);
   } finally {
     lock.unlock();
   }
 }
 /**
  * Called when a message is received from the client. Processes the given message and generates
  * events based on its content.
  */
 public void receiveMessage(Protos.TwoWayChannelMessage msg) {
   lock.lock();
   try {
     checkState(connectionOpen);
     if (channelSettling) return;
     // If we generate an error, we set errorBuilder and closeReason and break, otherwise we return
     Protos.Error.Builder errorBuilder;
     CloseReason closeReason;
     try {
       switch (msg.getType()) {
         case CLIENT_VERSION:
           receiveVersionMessage(msg);
           return;
         case PROVIDE_REFUND:
           receiveRefundMessage(msg);
           return;
         case PROVIDE_CONTRACT:
           receiveContractMessage(msg);
           return;
         case UPDATE_PAYMENT:
           checkState(step == InitStep.CHANNEL_OPEN && msg.hasUpdatePayment());
           receiveUpdatePaymentMessage(msg.getUpdatePayment(), true);
           return;
         case CLOSE:
           receiveCloseMessage();
           return;
         case ERROR:
           checkState(msg.hasError());
           log.error(
               "Client sent ERROR {} with explanation {}",
               msg.getError().getCode().name(),
               msg.getError().hasExplanation() ? msg.getError().getExplanation() : "");
           conn.destroyConnection(CloseReason.REMOTE_SENT_ERROR);
           return;
         default:
           final String errorText =
               "Got unknown message type or type that doesn't apply to servers.";
           error(
               errorText,
               Protos.Error.ErrorCode.SYNTAX_ERROR,
               CloseReason.REMOTE_SENT_INVALID_MESSAGE);
       }
     } catch (VerificationException e) {
       log.error("Caught verification exception handling message from client", e);
       error(
           e.getMessage(),
           Protos.Error.ErrorCode.BAD_TRANSACTION,
           CloseReason.REMOTE_SENT_INVALID_MESSAGE);
     } catch (ValueOutOfRangeException e) {
       log.error("Caught value out of range exception handling message from client", e);
       error(
           e.getMessage(),
           Protos.Error.ErrorCode.BAD_TRANSACTION,
           CloseReason.REMOTE_SENT_INVALID_MESSAGE);
     } catch (InsufficientMoneyException e) {
       log.error("Caught insufficient money exception handling message from client", e);
       error(
           e.getMessage(),
           Protos.Error.ErrorCode.BAD_TRANSACTION,
           CloseReason.REMOTE_SENT_INVALID_MESSAGE);
     } catch (IllegalStateException e) {
       log.error("Caught illegal state exception handling message from client", e);
       error(
           e.getMessage(),
           Protos.Error.ErrorCode.SYNTAX_ERROR,
           CloseReason.REMOTE_SENT_INVALID_MESSAGE);
     }
   } finally {
     lock.unlock();
   }
 }