Regarding this tool: Get Proxy Votes on Steem Blockchain, In case you might not notice, this tool also returns the indirect proxy supporters.

For example, danielhuhservice proxies to der-prophet, who sets proxy to steemchiller.

Recursive Algorithms to Get Both Direct/Indirect Proxy Voters

If you perform real-time scan backwards on the steem blockchain, it is hard to obtain the indirect proxy because for each direct proxy, you have to spawn new thread search their account history.

Real-time processing is slow, and thus we process and sync the blocks into a database (e.g. SQLite). Suppose you can use a SQL to obtain the direct proxy voters like this:

1
2
3
4
5
6
7
8

def getProxy(account):
   sql = "select account from proxy where proxy=" + account;
   con.exec(sql)
  data = []
   for row in cur.fetchall():
    # recursive 
     data.append({"account": row[0], "voters": getProxy(row[0])
  return data

def getProxy(account):
   sql = "select account from proxy where proxy=" + account;
   con.exec(sql)
  data = []
   for row in cur.fetchall():
    # recursive 
     data.append({"account": row[0], "voters": getProxy(row[0])
  return data

Here it is the beauty of the recursion. We call the function itself to fill the voters array of the current proxy.

Terminating the Recursion

Usually, for recursion to work, you have to set a terminal condition, otherwise, the recursive calls might go forever which causes the infamous “Stack Overflow”.

But in our case, the steem blockchain, this might be ok without it. As you can’t broadcast a proxy vote to someone who proxies you back, or even proxies to someone who proxies to you – which causes a loop.

You can, however, pass a maximum depth value (as a second parameter), as a safety check.

1
2
3
4
5
6
7
8
9
10
11

def getProxy(account, depth = 99):
  if depth == 0:
      # max depth exceeded, just return empty array
      return []
   sql = "select account from proxy where proxy=" + account;
   con.exec(sql)
  data = []
   for row in cur.fetchall():
    # recursive 
     data.append({"account": row[0], "voters": getProxy(row[0], depth - 1)
  return data

def getProxy(account, depth = 99):
  if depth == 0:
      # max depth exceeded, just return empty array
      return []
   sql = "select account from proxy where proxy=" + account;
   con.exec(sql)
  data = []
   for row in cur.fetchall():
    # recursive 
     data.append({"account": row[0], "voters": getProxy(row[0], depth - 1)
  return data

Here, the default maximum recursion depth is 100, when it exceeds, it will stop further recursive calls and simply return empty array.

–EOF (The Ultimate Computing & Technology Blog) —