While many of you know me for my "political" or "artistic" work on the site my true passion is developing and programming all sorts of things. STEEM stuff is challenging and fun to build!

Currently I've got a number of projects on the go in regards to our STEEM network. It's actually very exciting for me to be spearheading and developing the tools and services I am. However recently I've run into a bit of a snag in my development work and have decided to reach out to the community for help solving the issues I'm currently facing in development.

Put in the simplest way: I need a hand with building a system to monitor the STEEM blockchain for deposits to various services. I've begun work on my own accord to get this necesarry system built but unfortunately haven't had much luck in getting it to fire.

I Believe I Understand the Concept of STEEM Deposits

The way to monitor for deposits seems simple enough.. STEEM blocks aren't encrypted an if you're able to parse the transfers in the blocks and check them for your projects name and the memo attached matches certain variables set by your deposit rules then X amount of STEEM or SBD would be credited to the account in question.

What I'd started building my deposit scripts off of is linked below!

Written in Node.js and sourced from:
https://steem.io/documentation/how-monitor-account-deposits/

var rpc = require('node-json-rpc');

// Block to check from
  var last_block = 160900;
// Account to monitor for
  var watch_account = "world";
// Connection settings
  var options = {
      port: 8092,
      host: '127.0.0.1',
      path: '/rpc',
      strict: false
  };

// Outgoing RPC Call code
  var callrpc = function(name, params, cb) {
      client.call(
          {"jsonrpc": "2.0",
           "method": name,
           "params": params,
           "id": 0},
          function(err, res) {
             if (err) { cb(err, null) }
             else { cb(null, res["result"]) }
          }
      );
  }

// Block parsing bits?
  var process_transfer = function(op, block, blockid) {
      console.log(block);
      if (op["to"] == watch_account) {
          console.log(blockid + " | " + 
                      block["timestamp"] + " | "+
                      op["from"] + " -> " +
                      op["to"] + ": " +
                      op["amount"] + " -- " +
                      op["memo"]
              );
      }
  }


// More block parsing for transfers?
  var process_block = function(block, blockid) {
      console.log(blockid);
      console.log(block["transactions"]);
      for (var tx in block["transactions"]) {
          for (var opObj in tx["operations"]) {
              var opType = opObj[0];
              var op = opObj[1];

              console.log(op);

              if (opType == "transfer") {
                  process_transfer(op, block, blockid);
              }
          }
      }
  }

// Loop and check next block if not caught up
  var start_loop = function() {
      callrpc("get_dynamic_global_properties", [], function(err, props) {
          var block_number = props["last_irreversible_block_num"];
          while ((block_number - last_block) > 0) {
              last_block += 1
              callrpc("get_block", [last_block], function(err, block) {
                  process_block(block, last_block);
              });
          }
      });
  }


  var client = new rpc.Client(options);

  var block_interval;
// See what the block times are like
  callrpc("get_config", [],
          function (err, config) {
              if (err) { console.log(err); }
              else {
                  block_interval = config["STEEMIT_BLOCK_INTERVAL"]
                  start_loop();
              }
          }
         )

I've had limited success with the code above. I was seemingly able to get it started on checking all of the blocks for my test deposits but seemingly haven't been able to get it to run as I would like. Two things I'm still very much trying to figure out:

1. Is their a way to make the script above less resource intensive? It currently eats resources like a bastard.

2. I realize that block times are 3 seconds... But how does one know when the last reversible block is passed from the deposit in order to allow withdrawal or credit to account?

I know a number of folks have been using Piston based scripts or tools to monitor the blockchain for deposits. While I'm not against using Piston or Python3 I'd like to get a working Node.js deposit script going in order to minimize the amount of dependencies needed to deploy deposit systems into my projects. Has anyone got a Node.js STEEM deposit script with examples beyond what I've shown above that they are using and willing to share with me to help with my projects?

Looking for Piston Bot Code Too!

Also, Side note (Piston Related) does anyone have the sourcecode available for the bot functionality to call a bot or script it in comments sections? I remember seeing a post that had all code needed to build a listening / replying bot based off of piston but cannot for the life of me remember the author nor post name to search it.

Basically the functionality I am looking for is a user would use an @name call followed by a command. The code to simply have the calls register on my side should be enough to get me tinkering on a side project that STEEM desperately needs but hasn't got yet.

Thank you for taking the time to read this. All the Developer brains get at me please!