Verify unsigned transaction will be accepted before transmitting signed transaction

Author: unusualbob

examples/bitcoinRpc.js

@@ -181,10 +181,10 @@ async.waterfall([
         console.log('Bitcoind did not return a signed transaction');
         return cb(new Error('Missing signed tx'));
       }
-      cb(null, signedTransaction.hex);
+      cb(null, fundedRawTransaction, signedTransaction.hex);
     });
   },
-  function displayTransactionToUserForApproval(signedRawTransaction, cb) {
+  function getSignedTransactionSize(fundedRawTransaction, signedRawTransaction, cb) {
     let command = {
       jsonrpc: '1.0',
       method: 'decoderawtransaction',
@@ -197,52 +197,88 @@ async.waterfall([
         return cb(err);
       }
       if (!decodedTransaction) {
-        console.log('Bitcoind did not return a decoded transaction');
+        console.log('Bitcoind did not decode the transaction');
         return cb(new Error('Missing decoded tx'));
       }
-
-      console.log(JSON.stringify(decodedTransaction, null, 2));
-
-      promptly.confirm('Send payment shown above? (y/n)', function (err, accept) {
-        if (!accept) {
-          console.log('Payment cancelled');
-          return cb(new Error('Payment Cancelled'));
-        }
-        return cb(null, signedRawTransaction);
-      });
+      cb(null, fundedRawTransaction, signedRawTransaction, decodedTransaction.vsize);
     });
   },
-  function sendTransactionToServer(signedRawTransaction, cb) {
-    paymentProtocol.sendPayment(config.currency, signedRawTransaction, paymentUrl, function (err, response) {
+  function checkIfTransactionWillBeAccepted(fundedRawTransaction, signedRawTransaction, weightedSize, cb) {
+    console.log('Sending unsigned transaction to server for verification...');
+
+    paymentProtocol.sendPaymentForVerification(config.currency, fundedRawTransaction, weightedSize, paymentUrl, (err) => {
       if (err) {
-        console.log('Error sending payment to server', err);
+        console.log('Error verifying payment with server', err);
         return cb(err);
-      }
-      else {
-        console.log('Payment accepted by server');
+      } else {
+        console.log('Payment verified by server');
         return cb(null, signedRawTransaction);
       }
     });
   },
-  //Note we only broadcast AFTER a SUCCESS response from the server
-  function broadcastPayment(signedRawTransaction, cb) {
+  //Note we only broadcast AFTER a SUCCESS response from the server verification request
+  function displayTransactionToUserForApproval(signedRawTransaction, cb) {
     let command = {
       jsonrpc: '1.0',
-      method: 'sendrawtransaction',
+      method: 'decoderawtransaction',
       params: [signedRawTransaction]
     };
 
-    execRpcCommand(command, function (err, signedTransaction) {
+    execRpcCommand(command, function (err, decodedTransaction) {
       if (err) {
-        console.log('Error broadcasting transaction:', err);
+        console.log('Error signing transaction:', err);
         return cb(err);
       }
-      if (!signedTransaction) {
-        console.log('Bitcoind failed to broadcast transaction');
-        return cb(new Error('Failed to broadcast tx'));
+      if (!decodedTransaction) {
+        console.log('Bitcoind did not return a decoded transaction');
+        return cb(new Error('Missing decoded tx'));
       }
-      cb();
+
+      console.log(JSON.stringify(decodedTransaction, null, 2));
+
+      promptly.confirm('Send payment shown above? (y/n)', function (err, accept) {
+        if (!accept) {
+          console.log('Payment cancelled');
+          return cb(new Error('Payment Cancelled'));
+        }
+        return cb(null, signedRawTransaction);
+      });
     });
+  },
+  function broadcastPayment(signedRawTransaction, cb) {
+    async.parallel([
+      function sendToServer(cb) {
+        paymentProtocol.broadcastPayment(config.currency, signedRawTransaction, paymentUrl, function(err) {
+          if (err) {
+            console.log('Error sending payment to server', err);
+            return cb(err);
+          }
+          else {
+            console.log('Payment accepted by server');
+            return cb(null, signedRawTransaction);
+          }
+        });
+      },
+      function broadcastP2P(cb) {
+        let command = {
+          jsonrpc: '1.0',
+          method: 'sendrawtransaction',
+          params: [signedRawTransaction]
+        };
+
+        execRpcCommand(command, function (err, signedTransaction) {
+          if (err) {
+            console.log('Error broadcasting transaction:', err);
+            return cb(err);
+          }
+          if (!signedTransaction) {
+            console.log('Bitcoind failed to broadcast transaction');
+            return cb(new Error('Failed to broadcast tx'));
+          }
+          cb();
+        });
+      }
+    ], cb);
   }
 ], function (err) {
   if (err) {

index.js

@@ -195,11 +195,73 @@ PaymentProtocol.prototype.parsePaymentRequestAsync = util.promisify(PaymentProto
 /**
  * Sends a given payment to the server for validation
  * @param currency {string} Three letter currency code of proposed transaction (ie BTC, BCH)
+ * @param unsignedRawTransaction {string} Hexadecimal format raw unsigned transaction
+ * @param weightedSize {number} Weighted size of the transaction
+ * @param url {string} the payment protocol specific url (https)
+ * @param callback {function} (err, response)
+ */
+PaymentProtocol.prototype.sendPaymentForVerification = function sendPayment(currency, unsignedRawTransaction, weightedSize, url, callback) {
+  let paymentResponse;
+
+  //Basic sanity checks
+  if (typeof unsignedRawTransaction !== 'string') {
+    return callback(new Error('unsignedRawTransaction must be a string'));
+  }
+  if (!/^[0-9a-f]+$/i.test(unsignedRawTransaction)) {
+    return callback(new Error('unsignedRawTransaction must be in hexadecimal format'));
+  }
+  if (typeof weightedSize !== 'number' || parseInt(weightedSize) !== weightedSize) {
+    return callback(new Error('weightedSize must be an integer'));
+  }
+
+  let requestOptions = _.merge(this.options, {
+    url: url,
+    headers: {
+      'Content-Type': 'application/verify-payment'
+    },
+    body: JSON.stringify({
+      currency: currency,
+      transactions: [unsignedRawTransaction],
+      weightedSize: weightedSize
+    })
+  });
+
+  request.post(requestOptions, (err, response) => {
+    if (err) {
+      return callback(err);
+    }
+    if (response.statusCode !== 200) {
+      return callback(new Error(response.body.toString()));
+    }
+
+    try {
+      paymentResponse = JSON.parse(response.body);
+    }
+    catch (e) {
+      return callback(new Error('Unable to parse response from server'));
+    }
+
+    callback(null, paymentResponse);
+  });
+};
+
+/**
+ * Sends a given payment to the server for validation
+ * @param currency {string} Three letter currency code of proposed transaction (ie BTC, BCH)
+ * @param unsignedRawTransaction {string} Hexadecimal format raw unsigned transaction
+ * @param weightedSize {number} Weighted size of the transaction
+ * @param url {string} the payment protocol specific url (https)
+ */
+PaymentProtocol.prototype.sendPaymentForVerificationAsync = util.promisify(PaymentProtocol.prototype.sendPaymentForVerification);
+
+/**
+ * Sends actual payment to server
+ * @param currency {string} Three letter currency code of proposed transaction (ie BTC, BCH)
  * @param signedRawTransaction {string} Hexadecimal format raw signed transaction
  * @param url {string} the payment protocol specific url (https)
  * @param callback {function} (err, response)
  */
-PaymentProtocol.prototype.sendPayment = function sendPayment(currency, signedRawTransaction, url, callback) {
+PaymentProtocol.prototype.broadcastPayment = function broadcastPayment(currency, signedRawTransaction, url, callback) {
   let paymentResponse;
 
   //Basic sanity checks
@@ -246,7 +308,7 @@ PaymentProtocol.prototype.sendPayment = function sendPayment(currency, signedRaw
  * @param signedRawTransaction {string} Hexadecimal format raw signed transaction
  * @param url {string} the payment protocol specific url (https)
  */
-PaymentProtocol.prototype.sendPaymentAsync = util.promisify(PaymentProtocol.prototype.sendPayment);
+PaymentProtocol.prototype.broadcastPaymentAsync = util.promisify(PaymentProtocol.prototype.broadcastPayment);
 
 module.exports = PaymentProtocol;