Recursive Algorithm to Get Proxy Votes on Steem Blockchain

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

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:
Top Reasons Why Your Blog Sucks at Making Money (and How to Fix
How To Write A Great Product Placement Blog Post
Structured Data for SEO Blogging
5 Ways a Blog Can Help Your Business Grow
How to Create Killer Project Proposals to Land Five-Figure Blogg
Why Local SEO Is the Best Option for Promoting Your Website
Greedy Algorithm to Group the Numbers/Items Given the Group Size
Design A Leaderboard using Priority Queue, Hash Map (unordered_m
5 Innovative Ways Ecommerce Businesses Are Leveraging Machine Le
How to Compute the Catalan Numbers using Dynamic Programming Alg
Share:Facebook Twitter
Comment list
Comment add