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;
}
}
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();
}
}