Recursive Algorithm to Get Proxy Votes on Steem Blockchain

  • Time:2020-09-09 13:08:38
  • Class:Weblog
  • Read:41

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) —

Recommend:
Dynamic Programming Algorithm to Compute the Block Sum in a Matr
Smallest Multiple Algorithm using Bruteforce or GCD/LCM
How many different ways can £2 be made using any number of coins
Compute Factorial Digit Sum: Find the sum of the digits in the n
Compute the Maximum Integer Right Triangles Solutions
Power Digit Sum: What is the sum of the digits of the number 2^1
Digit factorials: Find the Sum of All the Curious Numbers
Computing the Longest Recurring Cycle in its Decimal Fraction Pa
How to Use Priority Queue in Java or C++ to Compute Last Stone W
5 Most Important SEO Keyword Metrics, Explained
Share:Facebook Twitter
Comment list
Comment add