DEV Community: Aditya Chaudhary👨‍💻

Run Frontend of BitClout without running node

Aditya Chaudhary👨‍💻 — Wed, 07 Jul 2021 12:31:26 +0000

You might want to make some changes to the frontend of BitClout but running a node is beyond your league ? Well, you are on the right place of the Internet then!

You can easily run the frontend of BitClout locally on your PC without running node by using some browser hacks :)
If you were to follow the official docs of BitClout, you will have to run your own node (aka backend) and identity service in order to run the frontend.
While you read further you must know that this article is about running the frontend for local development only and you can't deploy the frontend for public use. The only use case of this article is to set up the frontend development environment locally so that you can make pull request and contribute to the frontend of BitClout.

Before you get started make sure you are using the latest version of NodeJS and NPM on your PC. Another prerequisite is to have git installed. The frontend of BitClout is made in AngularJS so you must have atleast some basic knowledge of what single page application is.

Fork and Clone the frontend repository.

Fork the repository of the frontend from here. When done open your terminal and run git clone <https://github.com/YOUR_GITHUB_USERNAME/frontend>

Open the frontend in your code editor

Now change the current working directory into the newly created frontend folder by cd frontend.
You can open the frontend folder in your code editor to scroll through the code. We are using Visual Studio Code here. Run code . in the terminal to open the folder in VS Code.

Now you have the frontend code of the world's best social media on your PC :)

Install project dependencies

As mentioned earlier, the frontend of BitClout is made in AngularJS. To install all the project dependencies run npm install in your terminal. This may take a while.

If everything went good, you may only get some warnings (or worst case tons of errors. If this is the case, google your problem)

Run the frontend

To run the frontend on your browser run ng serve in your terminal. This may take some time since there are bunch of files to compile.

Have your fingers crossed and let the code compile. For my case I got some circular dependency warnings, but finally I can see my frontend live at http://localhost:4200/

Open your browser at http://localhost:4200/ and have dev tools open. In the dev tools you will see tons errors. Congratulation! You have almost set-up the frontend dev environment!

Point the node to BitClout's main node

By default, your browser will point the node to a local hosted node (which does not exists in our case because we are only running the frontend). So you need to point the node to the main node of bitclout.
Just open up the dev tools in your browser, go to the applications tab and in the local storage of http://localhost:4200 change lastLocalNodeV2 to "https://bitclout.com"
Here is an image to get things easier:

If you now reload the page and check your dev tools you will notice that you still have tons of errors. These errors are known as CORS errors. For the sake of security, browsers block cross origin resource sharing. Here you are sharing the resource of https://bitclout.com through you local host i.e https://localhost:4200.

Unblock CORS for one's browser

You now need to unblock CORS by using some third party extensions. For our case we are using CORS Unblock browser extension

NOTE: Use this extension only when it's required and have it disabled most of the time. There is security reasons why your browser gives CORS error

Install the extension and enable it while you want to run the BitClout's frontend through the main node. Make sure you have enabled all forms of CORS unblock especially the Enable Access-Control-[Allow/Expose]-Headers.
Have the extension on with all the above mentioned settings and reload the page!
Now login with the identity service and you have your frontend running locally on your PC without running node!

Here is a preview of the frontend on my local host!

Congratulations! You are now running the frontend of the world's best social media (Ok, I maybe biased)
Why not improve some UI and do some PR ?

If you like the article don't forget to let us know in the comments or maybe give a shout to DevsClout ? You can also join DevsClout discord server to chat with more devs who are building awesome projects on BitClout! We would love to hear back from you!

How to make post on BitClout using BItClout API

Aditya Chaudhary👨‍💻 — Fri, 25 Jun 2021 07:24:32 +0000

Creating a BitClot post isn't that straightforward. If you have ever used Twitter API (aka Tweepy) you might recall that tweeting through the API was really easy and convenient. All you needed to do was to call the predefined functions of the twitter API. This isn't the case with BItClout. If you have to make post or any transaction (since post is also a transaction) you will have to go through 3 major steps:

Step 1: Get the post transaction Hex

Step 2: Sign the transaction Hex

Step 3: Submit the transaction.

While the step 1 and step 3 is fairly easy, the step 2 is where a lot of people find it difficult to get through. This is where this article can come handy for those people! You must note that this article is only for creating post from YOUR account only. You must not try to create any service (like schedule post or something) which will make post on other user's behalf. It is also recommended to use a test account to follow this tutorial because you will be using the seedHex of your account in your code. The seedHex in other language is as powerful as your BitClout seed phrase. If someone have access to your seedHex they can do ANYTHING with your account. If you are in crypto world from long time, you might know the risk of storing seed phrase (or seed Hex) on a computer or anywhere online. That's why you must use a test account to follow this tutorial (I repeat).

Before we get started, I want to let you know that this complete tutorial is in Python and it is must that you should be comfortable with the basics of python atleast.

Getting the post transaction Hex: This step is fairly simple enough. All you need is to collect the transactionHex of the required post from the https://bitclout.com/api/v0/submit-post endpoint. Below is a python function that returns the transactionHex for a post

import json
import requests

def getPostTransaction(publicKey, body, imageUrl): 

  header = {
        "content-type": "application/json"
    }

  payload= {"UpdaterPublicKeyBase58Check": publicKey,
    "PostHashHexToModify": "",
    "ParentStakeID": "",
    "Title": "",
    "BodyObj": {"Body": body, "ImageURLs": imageUrl},
    "RecloutedPostHashHex": "",
    "PostExtraData": {},
    "Sub": "",
    "IsHidden":  False,
    "MinFeeRateNanosPerKB": 1000}

  res = requests.post(
        "https://bitclout.com/api/v0/submit-post", json=payload, headers=header)

  resJson = res.json()
  transactionHex = resJson["TransactionHex"]
  return transactionHex

In the above code snippet, publicKey refers to the public key of the account through which you want to make the post, body is a string referring to the post content and imageURL is a list type variable that stores the image URLs which you want to post on BitClout. You can pass imageURL to [] if you don't want top post image in your clout ( clout is to BitClout as tweet is to twitter )

Signing the TransactionHex: The next and most important step is to sign the transaction. But wait, what does signing a transaction means ? Well, you are doing a transaction from an account so you can relate it as a bank account transaction where there must be a signature of the bank account owner. Does that makes sense ? The signature part is to make sure that the transaction is being done from the account owner himself and not from any thief*. BitClout has developed their own Identity service which is used to sign the transaction.

There are third party transaction signing APIs like this but as the author of the API himself says that the API could have vulnerabilities which can be a breach to your account security, you must NOT use the above mentioned API to sign the transaction. But don't worry, there are other ways to sign the transaction!

The TransactionHex can be signed without using Identity service as well. Below is a python script that can sign the TransactionHex in few milliseconds! Create a new python file sign.py which contains the following script:

import hashlib
import hmac

def get_hmac(key, data):
    return hmac.new(key, data, hashlib.sha256).digest()

def hmac_drbg(entropy, string):
    material = entropy + string
    K = b"\x00" * 32
    V = b"\x01" * 32

    K = get_hmac(K, V + b"\x00" + material)
    V = get_hmac(K, V)
    K = get_hmac(K, V + b"\x01" + material)
    V = get_hmac(K, V)

    temp = b""
    while len(temp) < 32:
        V = get_hmac(K, V)
        temp += V

    return temp[:32]

#######

g=(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
    0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)
p=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
n = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

def point_add(point1, point2):
    # Returns the result of point1 + point2 according to the group law.
    if point1 is None:
        return point2
    if point2 is None:
        return point1

    x1, y1 = point1
    x2, y2 = point2

    if x1 == x2 and y1 != y2:
        return None

    if x1 == x2:
        m = (3 * x1 * x1) * pow(2 * y1, -1, p)
    else:
        m = (y1 - y2) * pow(x1 - x2, -1, p)

    x3 = m * m - x1 - x2
    y3 = y1 + m * (x3 - x1)
    result = (x3 % p, -y3 % p)

    return result

def scalar_mult(k, point):
    # Returns k * point computed using the double and point_add algorithm.
    result = None
    addend = point

    while k:
        if k & 1:
            # Add.
            result = point_add(result, addend)
        # Double.
        addend = point_add(addend, addend)
        k >>= 1

    return result

#######

def to_DER(r, s): # Signature to DER format
    r = bytes.fromhex(r)
    s = bytes.fromhex(s)
    if r[0] > 0x80:
        r = bytes.fromhex("00")+r
    if s[0] > 0x80:
        s = bytes.fromhex("00")+s
    res = bytes.fromhex("02"+hex(len(r))[2:]) + r + bytes.fromhex("02"+hex(len(s))[2:]) + s
    res = bytes.fromhex("30"+hex(len(res))[2:]) + res

    return res.hex()



def Sign_Transaction(seedHex, TransactionHex):
    s256 = hashlib.sha256(hashlib.sha256(bytes.fromhex(TransactionHex)).digest()).digest()
    drbg = hmac_drbg(entropy=bytes.fromhex(seedHex), string=s256)
    k = int.from_bytes(drbg, 'big')
    kp = scalar_mult(k, g)
    kpX = kp[0]
    r = kpX % n
    s = pow(k, -1, n) * (r * int(seedHex, 16)+int(s256.hex(), 16))
    s = s % n
    signature = to_DER(hex(r)[2:].zfill(64), hex(s)[2:].zfill(64))
    signed_transaction = TransactionHex[:-2] + hex(len(bytearray.fromhex(signature)))[2:] + signature

    return signed_transaction

The method Sign_Transaction(seedHex, TransactionHex) takes seedHex and TransactionHex as two argument. You can find the seedHex of your account in your browser storage.
Just open https://bitclout.com/ > Dev tools > Application > Storage > Local Storage > https://identity.bitclout.com > users > Select the public key with which you want to post > seedHex

Note: Never share your seedHex with anyone. sharing seedHex is equivalent of sharing seed phrase

The second argument TransactionHex is the transaction which you want to sign.

On a side note, I didn't create the above code but I can make sure that the above code is secure! You can check the repo here.
Note: You must use the code of this article ONLY and NOT from any other repo mentioned in this article. The code in this article is secure and none of your private info like seedHex is being shared with any third party. Being on the safe side, you must review the code of sign.py on your own.

Submitting the signed post transaction: The third and last step is to submit the signed post TransactionHex. Below is a python code that submits the transaction using https://bitclout.com/api/v0/submit-transaction

import requests

def submitTransaction(signedTransactionHex):
    payload= {
        "TransactionHex": signedTransactionHex
    }
    response = requests.post(
        "https://bitclout.com/api/v0/submit-transaction", json=payload)

    return response.status_code

the submitTransaction method only takes signedTransactionHex as argument.

This is what the 3 required steps are to make post on BitClout. Summing up the above 3 steps, below is a 100% working code.


import os
import requests
import json
import hashlib
import hmac


def getPostTransaction(publicKey, body, imageUrl): 

  header = {
        "content-type": "application/json"
    }

  payload= {"UpdaterPublicKeyBase58Check": publicKey,
    "PostHashHexToModify": "",
    "ParentStakeID": "",
    "Title": "",
    "BodyObj": {"Body": body, "ImageURLs": imageUrl},
    "RecloutedPostHashHex": "",
    "PostExtraData": {},
    "Sub": "",
    "IsHidden":  False,
    "MinFeeRateNanosPerKB": 1000}

  res = requests.post(
        "https://bitclout.com/api/v0/submit-post", json=payload, headers=header)

  resJson = res.json()
  transactionHex = resJson["TransactionHex"]
  return transactionHex


def get_hmac(key, data):
    return hmac.new(key, data, hashlib.sha256).digest()

def hmac_drbg(entropy, string):
    material = entropy + string
    K = b"\x00" * 32
    V = b"\x01" * 32

    K = get_hmac(K, V + b"\x00" + material)
    V = get_hmac(K, V)
    K = get_hmac(K, V + b"\x01" + material)
    V = get_hmac(K, V)

    temp = b""
    while len(temp) < 32:
        V = get_hmac(K, V)
        temp += V

    return temp[:32]

#######

g=(0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798,
    0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8)
p=0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f
n = 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141

def point_add(point1, point2):
    # Returns the result of point1 + point2 according to the group law.
    if point1 is None:
        return point2
    if point2 is None:
        return point1

    x1, y1 = point1
    x2, y2 = point2

    if x1 == x2 and y1 != y2:
        return None

    if x1 == x2:
        m = (3 * x1 * x1) * pow(2 * y1, -1, p)
    else:
        m = (y1 - y2) * pow(x1 - x2, -1, p)

    x3 = m * m - x1 - x2
    y3 = y1 + m * (x3 - x1)
    result = (x3 % p, -y3 % p)

    return result

def scalar_mult(k, point):
    # Returns k * point computed using the double and point_add algorithm.
    result = None
    addend = point

    while k:
        if k & 1:
            # Add.
            result = point_add(result, addend)
        # Double.
        addend = point_add(addend, addend)
        k >>= 1

    return result

#######

def to_DER(r, s): # Signature to DER format
    r = bytes.fromhex(r)
    s = bytes.fromhex(s)
    if r[0] > 0x80:
        r = bytes.fromhex("00")+r
    if s[0] > 0x80:
        s = bytes.fromhex("00")+s
    res = bytes.fromhex("02"+hex(len(r))[2:]) + r + bytes.fromhex("02"+hex(len(s))[2:]) + s
    res = bytes.fromhex("30"+hex(len(res))[2:]) + res

    return res.hex()



def Sign_Transaction(seedHex, TransactionHex):
    s256 = hashlib.sha256(hashlib.sha256(bytes.fromhex(TransactionHex)).digest()).digest()
    drbg = hmac_drbg(entropy=bytes.fromhex(seedHex), string=s256)
    k = int.from_bytes(drbg, 'big')
    kp = scalar_mult(k, g)
    kpX = kp[0]
    r = kpX % n
    s = pow(k, -1, n) * (r * int(seedHex, 16)+int(s256.hex(), 16))
    s = s % n
    signature = to_DER(hex(r)[2:].zfill(64), hex(s)[2:].zfill(64))
    signed_transaction = TransactionHex[:-2] + hex(len(bytearray.fromhex(signature)))[2:] + signature

    return signed_transaction


def submitTransaction(signedTransactionHex):
    payload= {
        "TransactionHex": signedTransactionHex
    }
    response = requests.post(
        "https://bitclout.com/api/v0/submit-transaction", json=payload)

    return response.status_code



if __name__ == "__main__":
  postBody = "In retrospect, it was inevitable 💎🤲 " #don't dare change this body, Diamondhands won't like you
  imageURL = []
  seedHex = "YOUR_SEED_HEX"  # It is recommended to store your seedHex as environment variable
  publicKey = "YOUR_PUBLIC_KEY" 

  postTxn = getPostTransaction(publicKey, postBody, imageURL)
  signedTxn = Sign_Transaction(seedHex,postTxn)
  status = submitTransaction(signedTxn)

  if status == 200:
    print("Post done!")
  else:
    print("Error " + str(status))

Below is the result of the above code:

Congrats! You made a post on BitClout through your code.

Getting posts of BitClout User

Aditya Chaudhary👨‍💻 — Fri, 18 Jun 2021 14:57:52 +0000

Just like the twitter API that gives tweet content and other information about tweets of users, BitClout API also offers the same feature but additionally, it also provides much more information about user's posts!

You can fetch any user's N number of posts through username. All you need is to make a POST request to https://bitclout.com/api/v0/get-posts-for-public-key
Below is a python code that fetches desired number of posts of any user:

import json
import requests

def getPostsOfUser(username, numberOfPosts):
  payload= {"PublicKeyBase58Check":"","Username":username,"ReaderPublicKeyBase58Check":"BC1YLhBLE1834FBJbQ9JU23JbPanNYMkUsdpJZrFVqNGsCe7YadYiUg","NumToFetch":numberOfPosts}
  #here ReaderPublicKeyBase58Check means the reader of the post. You can leave it as it is or just use your own public key. 
  response = requests.post(url="https://bitclout.com/api/v0/get-posts-for-public-key", json=payload)

  file = open("postsOfUser.json", "w")
  json.dump(response.json(), file)
  file.close()
  return response.status_code

if __name__ == "__main__":
  user = "ItsAditya"
  print(getPostsOfUser(user, 20))

If on execution of the above code prints response code 200, a new file named postsOfUser.json will be created that contains 20 posts by that user (Reclouts included)
The response JSON file looks like this

{
  "Posts": [
    {
      "PostHashHex": "b15caa1e109bcb4544acb2864e583b41db12e70790b435eac8ec45b875b4066b",
      "PosterPublicKeyBase58Check": "BC1YLhBLE1834FBJbQ9JU23JbPanNYMkUsdpJZrFVqNGsCe7YadYiUg",
      "ParentStakeID": "",
      "Body": "One interesting fact as stated by @ElonTusk is that the money was transferred to @PR12M which can be read as Prism which is a US based surveillance program\n\nRead more here: https://en.wikipedia.org/wiki/PRISM_(surveillance_program)",
      "ImageURLs": null,
      "RecloutedPostEntryResponse": {
        "PostHashHex": "8693d28eff9c5833173a33ac2bdea4ffaa7c3fc682fd6033d6837d78fbd4105d",
        "PosterPublicKeyBase58Check": "BC1YLhBLE1834FBJbQ9JU23JbPanNYMkUsdpJZrFVqNGsCe7YadYiUg",
        "ParentStakeID": "",
        "Body": "The compromised accounts who had lost money few days ago due to the \"hacks\" received their money back \ud83d\udc40\n\nMaybe all this was done just to teach a lesson? \ud83e\udd14 ",
        "ImageURLs": [],
        "RecloutedPostEntryResponse": null,
        "CreatorBasisPoints": 1000,
        "StakeMultipleBasisPoints": 12500,
        "TimestampNanos": 1623937618272511376,
        "IsHidden": false,
        "ConfirmationBlockHeight": 34779,
        "InMempool": false,
        "StakeEntry": {
          "TotalPostStake": 0,
          "StakeList": []
        },
        "StakeEntryStats": {
          "TotalStakeNanos": 0,
          "TotalStakeOwedNanos": 0,
          "TotalCreatorEarningsNanos": 0,
          "TotalFeesBurnedNanos": 0,
          "TotalPostStakeNanos": 0
        },
        "ProfileEntryResponse": {
          "PublicKeyBase58Check": "BC1YLhBLE1834FBJbQ9JU23JbPanNYMkUsdpJZrFVqNGsCe7YadYiUg",
          "Username": "ItsAditya",
          "Description": "17 year young | Programmer | Illustrator\n\nFounder: @DevsClout\n\nDev @knowyourclout  \u27a1\ufe0f @GlobalClout\n\nDiscord: https://discord.gg/ggvtTje ",
          "IsHidden": false,
          "IsReserved": false,
          "IsVerified": false,
          "Comments": null,
          "Posts": null,
          "CoinEntry": {
            "CreatorBasisPoints": 1000,
            "BitCloutLockedNanos": 50542099887,
            "NumberOfHolders": 263,
            "CoinsInCirculationNanos": 36972965086,
            "CoinWatermarkNanos": 38212986918
          },
          "CoinPriceBitCloutNanos": 4101005003,
          "StakeMultipleBasisPoints": 12500,
          "StakeEntryStats": {
            "TotalStakeNanos": 0,
            "TotalStakeOwedNanos": 0,
            "TotalCreatorEarningsNanos": 0,
            "TotalFeesBurnedNanos": 0,
            "TotalPostStakeNanos": 0
          },
          "UsersThatHODL": null
        },
        "Comments": null,
        "LikeCount": 29,
        "DiamondCount": 7,
        "PostEntryReaderState": {
          "LikedByReader": true,
          "DiamondLevelBestowed": 0,
          "RecloutedByReader": false,
          "RecloutPostHashHex": ""
        },
        "InGlobalFeed": true,
        "IsPinned": false,
        "PostExtraData": {},
        "CommentCount": 6,
        "RecloutCount": 3,
        "QuoteRecloutCount": 3,
        "ParentPosts": null,
        "DiamondsFromSender": 0
      },
      "CreatorBasisPoints": 1000,
      "StakeMultipleBasisPoints": 12500,
      "TimestampNanos": 1623939733768805958,
      "IsHidden": false,
      "ConfirmationBlockHeight": 34783,
      "InMempool": false,
      "StakeEntry": {
        "TotalPostStake": 0,
        "StakeList": []
      },
      "StakeEntryStats": {
        "TotalStakeNanos": 0,
        "TotalStakeOwedNanos": 0,
        "TotalCreatorEarningsNanos": 0,
        "TotalFeesBurnedNanos": 0,
        "TotalPostStakeNanos": 0
      },
      "ProfileEntryResponse": null,
      "Comments": null,
      "LikeCount": 4,
      "DiamondCount": 2,
      "PostEntryReaderState": {
        "LikedByReader": true,
        "DiamondLevelBestowed": 0,
        "RecloutedByReader": false,
        "RecloutPostHashHex": ""
      },
      "InGlobalFeed": false,
      "IsPinned": false,
      "PostExtraData": {},
      "CommentCount": 1,
      "RecloutCount": 1,
      "QuoteRecloutCount": 0,
      "ParentPosts": null,
      "DiamondsFromSender": 0
    }]
}

Getting posts of BitClout User

Aditya Chaudhary👨‍💻 — Fri, 18 Jun 2021 14:49:35 +0000

Liquid syntax error: 'raw' tag was never closed

Getting BitClout User Information using BitClout API

Aditya Chaudhary👨‍💻 — Thu, 17 Jun 2021 16:43:03 +0000

You might want to get BitClout user information for your next project, right ?
If yes, you are on the right page of the Internet!

We will be covering two BitClout API endpoints that provides user information including username, coin price, profile photo and other tons of information about any user.

To use the endpoints, you only need a prior knowledge of dealing with GET or POST requests. Since the article shows working code in python, it is must that you know some basic python atleast.
Of course you can use your desired language to do your task since it is only the game of GET and POST requests.

Let's get started!

The first and most preferred way to get user information is through "Public Key" of a user. The get-user-stateless endpoint returns a gigantic data in JSON format! Here is a working code of the endpoint:

import requests
import json

def getUserStateless(listOfPublicKeys): #the method takes List of PublicKey(s)
  endpoint = "https://api.bitclout.com/get-users-stateless"
  payload =  {"PublicKeysBase58Check": listOfPublicKeys}
  response = requests.post(endpoint, json = payload)

  file = open("userData.json", "w") #the response data will be saved in file "userData.json"
  json.dump(response.json(), file)
  file.close()

  return response.status_code #returning response code. 200 means successful !


if __name__ == "__main__":
 listOfPublicKeys = ["BC1YLhBLE1834FBJbQ9JU23JbPanNYMkUsdpJZrFVqNGsCe7YadYiUg"] #you can add more public keys in this list
 print(getUserStateless(listOfPublicKeyss)

The above code dumps the data returned by the endpoint in json file.
You can study the file "userData.json" to better understand the data.

You might want to see metrices like coin price etc. but for that you will have to do some basic calculations.
For example, if you want to get the coin price of the user, you will have to divide the CoinPriceBitCloutNanos by 1,000,000,000 and then multiply the resultant with the current price of BitClout in USD. In order to get the current price of BitClout, refer to this article.
The endpoint returns more than just a coin price. You can study the userData.json file to learn more!

The get-user-stateless returns gigantic data about the user but in some cases you might want to get only general information about the user like coin price, username, description, profile picture etc. That's where the get-single-profile endpoints come handy! Below is working python code to use the get-single-profile endpoint:

import requests
import json

def getSingleProfile(publicKey):
  payload= {"PublicKeyBase58Check":publicKey,"Username":""}
  response = requests.post(url="https://api.bitclout.com/get-single-profile", json=payload)

  file = open("singleProfile.json", "w")
  json.dump(response.json(), file)
  file.close()
  return response.status_code

if __name__ == "__main__":
  publicKey = "BC1YLhBLE1834FBJbQ9JU23JbPanNYMkUsdpJZrFVqNGsCe7YadYiUg"
  print(getSingleProfile(publicKey))

If the above code prints the status code 200, you will see a new file created in your working directory named "singleProfile.json" that has general information about the user. Be a geek and study it!

The above mentioned two endpoints accept public key of BitClout user to fetch the data but what if you want to get information of a user through user name ? Well, there is a way to do that!

You can simply use the get-single-profile to get the user information by passing the username only.

Here is a working python code to get general information of a user through username:

import json
import requests

def getInfoByUsername(username):
  payload = {"PublicKeysBase58Check": [""],
                "Username": username}
  response = requests.post(url="https://api.bitclout.com/get-single-profile", json=payload)

  file = open("getUserByName.json", "w")
  json.dump(response.json(), file)
  file.close()
  return response.status_code


if __name__ == "__main__":
  username = "ItsAditya"
  print(getInfoByUsername(username))

If the above code prints status code 200, you will see a new file created named "getUserByName.json" that has all the general information about that user.

Now it's totally your choice to get the information through public key or through username.
It must be noted that public key of a user is a constant entity which never changes while a username can be changed so it's a good practice to fetch the data through the public key.

Getting current BitClout Price using BitClout API

Aditya Chaudhary👨‍💻 — Thu, 17 Jun 2021 16:40:41 +0000

Getting the BitClout price is really a must needed data since calculation of coin price, market cap, Total USD locked etc. is dependent on the current BitClout price.

The workaround to get the current BitClout price in USD is really easy! All you need is to do a GET request to https://api.bitclout.com/get-exchange-rate to get the price of BitClout in BitCoin and then make a GET request to https://api.coindesk.com/v1/bpi/currentprice.json to get the current price of BitCoin in USD!

You are all set now!
Just multiply the Bitcoin price in USD with BitClout price in Bitcoin and you have the current price of BitClout!

Here is a working code in python.

import requests
def getBitCloutPrice():  # return BitClout price in USD
  response = requests.get("https://api.coindesk.com/v1/bpi/currentprice.json")
  data = response.json()
  bitcoin_price = float(
  data["bpi"]["USD"]["rate"].replace(",", ""))  # Bitcoin price in USD

  r = requests.get("https://api.bitclout.com/get-exchange-rate")
  bitclout_in_bitcoin = (
            int(r.json()["SatoshisPerBitCloutExchangeRate"]) * 0.00000001
        )  # Bitclout price in Bitcoin
  bitclout_price = bitcoin_price * bitclout_in_bitcoin  # Bitclout price in USD

  return bitclout_price

if __name__ == "__main__":
  print(getBitCloutPrice())

If you want to learn more about the price of BitClout and how it is actually calculated check out Tijn's Formula

Extracting Audio from Video Clips using Python

Aditya Chaudhary👨‍💻 — Sun, 07 Mar 2021 10:05:08 +0000

Hello World!

This mini blog is about how one can extract audio files from video clips using Python! This can be done in less than 5 lines of code but what is more important is to get started with Moviepy module.

We are going to take a look at Moviepy module of python which is widely used for editing videos using python.
Moviepy makes video editing painless in python and by using just few python one-liners one can get desired outcome!
Here we are going to extract audio file from a sample video file.
I have used a sample MP4 video clip in this blog. You can use any video file.

Let's get into the coding part!

First of all we need to install moviepy module in python by typing the following command in terminal window:

pip install moviepy

The next step is to install FFmpeg module. FFmpeg is a multimedia framework used for handling audio, video and other streams.
To install FFmpeg, type the following command in the terminal window:

pip install ffmpeg

If the installation was successful then you are all set up!

We will begin by importing the moviepy module:

import moviepy.editor as mp

The next step is to copy the sample video in the project folder and define the video file in python code. Moviepy comes with a handy VideoFileClip() method that imports the sample video as a moviepy object. Here is how you can import the video file inside the python code:

video = mp.VideoFileClip(r"sample.mp4") #here sample.mp4 is the name of video clip. 'r' indicates that we are reading a file

Now it's time to convert the video file into audio file. We will be converting the .mp4 file into .mp3 file. To do this add the following line in the program:

video.audio.write_audiofile(r"output.mp3")  #Here 'output.mp3' is the name of the audio file

You are all done!
The final code will look like this:

import moviepy.editor as mp

video = mp.VideoFileClip(r"sample.mp4")
video.audio.write_audiofile(r"output.mp3")

Run the program and wait for a while. You may see the progress in the terminal window

And that's it! 🎉 Check the project folder and you will see the output.mp3 file which has been extracted from the sample video file.

This was the first blog post about Moviepy. I will be creating more projects using it and will write blogs about them as well!
Stay tuned!

If you are stuck at any point, do let me know in the comments section or ping me in our discord server where 200+ programmers are hacking on something!

Making a Discord Bot using Discord.py

Aditya Chaudhary👨‍💻 — Sat, 14 Nov 2020 10:03:10 +0000

Discord is a messaging platform that enables users to communicate with texts, voice, media, video call in private chats or as a part of communities called "servers".
You might have used discord and have seen how efficient discord is when used with productive multi-purpose discord bots.
Ever wished to create a discord bot of your own?
Well, this post is going to guide you with the basics to get started with making a simple discord bot that will fetch Google Search Results Directly in your chats!

The final bot will look something like this:

Before getting started, make sure you have a discord server ( or just create a test server). For this blog I am using my own server: The Techies.

1. Setting up Discord.py

To install Disord.py, run pip install discord.py in your terminal. If everything goes well, you will see a successful installation message on your terminal.

2. Creating a discord application and bot

Before jumping onto the code, we need to create a discord application that will hold our bot. Access the Discord Developers Portal here and create a new application.

Give a name to your application to proceed.

Give a description of your application and upload a profile photo of your bot(not mandatory though)

Now we need to add a bot to our application. To do this go to the Bot tab under settings and click Add Bot.

A bot needs specific permissions to perform action in the server. Generally a bot has Administrator permission so that nothing could hinder the bot from performing any task. So make sure you give administrator permission to your bot.

3. Inviting the bot to the test server.

Now you are mostly done to setup your bot and it's time to invite your bot to your server. To do this go to OAuth2 tab under settings and in the scopes section select the bot checkbox and open the generated URL in New tab.

The generated URL will enable you to invite the bot to your server.
Select the server where you want the bot to be invited and after solving the captcha, your bot will enter your server!

Check your discord server now, and you will see the arriving message of your bot!

You will notice that your bot is offline. This is because you haven't added life to your bot via code yet.

Now we are mostly done with setting up our bot and it's time to jump into coding part and a life to the bot!

4. Adding life to our bot.

Since we are going to fetch Google search results in this process we will need the Google Packages. The package needs one more external dependency beautifulsoup4 which is responsible for fetching information from web pages.
To install beautifulsoup4 run pip install beautifulsoup4
To install Google Packages run pip install google

You are all set now!
Create a bot.py file and import necessary modules:

import discord
from discord.ext import commands
from googlesearch import search

Now give a prefix to your bot. A prefix is usually a symbol that is mainly used give commands to the bot. You can relate a prefix with words like pseudo, pip, ,$ npm etc.

client = commands.Bot(command_prefix = 'just')

You will be using this client variable to reference to specific events
Quoting from the official documentation,

discord.py revolves around the concept of events. An event is something you listen to and then respond to. For example, when a message happens, you will receive an event about it that you can respond to."

To connect your bot to the bot.py application, you will need Secret Token of your Bot. You can find the token in the Bot tabs under the settings:

PS. Never share secret token. It is something that should be kept private.

Now if you will add this code snippet and run it you will find your bot online! Congratulations. You added life to the bot!

@client.event
async def on_ready(): #triggered when the bot is online
    print("Bot is ready")
client.run("Secret Token Of your Bot")

Now to make the bot to fetch results from Google we need to add few lines of code:

@client.event
async def on_message(message):
    if message.content.startswith('just google'):
        searchContent = ""
        text = str(message.content).split(' ')
        for i in range(2, len(text)):
            searchContent = searchContent + text[i]

        for j in search(searchContent, tld="co.in", num=1, stop=1, pause=2):
            await message.channel.send(j)

Now let's break down this code.
The very first line@client.event is a decorator to register an event in a callback manner which is triggered when something happens.
The on_message(message): is an asynchronous function that takes an argument "message" which is actually the text of the user.

Now the bot needs to search through every message in the server and perform the Google search when any user texts just google
To do this we have added this code

 if message.content.startswith('just google'):
        searchContent = ""
        text = str(message.content).split(' ')
        for i in range(2, len(text)):
            searchContent = searchContent + text[i]

Here the message.content.startswith('just google") checks if the text message has "just google" command in the beginning. If this is true the words after the command is stored in variable searchContent.

Now we have the word to search on Google, and send the fetched results back to the chats. We did this by this code:

for j in search(searchContent, tld="co.in", num=1, stop=1, pause=2):
            await message.channel.send(j)

You can change the value of stop and num depending upon the number of search results you want on your server. For the sake of simplicity we have taken it 1 for both the arguments.

You are all done!
Make sure your final code looks like this

import discord
from discord.ext import commands
from googlesearch import search 


client = commands.Bot(command_prefix = '.')

@client.event
async def on_ready():
    print("Bot is ready")


@client.event
async def on_message(message):
    if message.content.startswith('just google'):
        searchContent = ""
        text = str(message.content).split(' ')
        for i in range(2, len(text)):
            searchContent = searchContent + text[i]

        for j in search(searchContent, tld="co.in", num=1, stop=1, pause=2):
            await message.channel.send(j)

client.run("Secret Token Of your Bot")

Run the bot.py file and wait for a while till you get the message "Bot is ready" on your terminal.
Now it's time to test the bot!
Type "just google Fibonacci Series" and the bot will fetch the results in the server.

Congratulations! You made a handy bot!

For any help you can join my Discord Server and ping me anytime!

Screen Recording using python

Aditya Chaudhary👨‍💻 — Fri, 23 Oct 2020 06:17:13 +0000

In this article we are going to take a look at how we can record our screen using Python. Before getting into it, one should firstly understand what actually a video is. Basically, a video is nothing but a sequence of images (called frames) displayed at a given frequency.

So a workaround to make a screen recorder would be to capture each frame of the screen and write it as a video file. To do this python comes with handy libraries. For the screen recording we will be using OpenCV, PyAutoGUI, and Numpy.

So let's get started!
Make sure you have all the above mentioned necessary libraries installed.

OpenCV : To install OpenCV, run pip install opencv-python
PyAutoGui : To install PyAutoGui, run pip install pyautogui
Numpy : To install Numpy, run pip install numpy You are all set!

First step is to import all the modules needed.

import cv2 #OpenCV
import pyautogui
import numpy as np

The next step is to specify video codec using fourCC. It is a 4 byte code used for specifying the video codec. For the sake of simplicity we can pass the FourCC code for AVI video format which is *"XVID"

codec = cv2.VideoWriter_fourcc(*"XVID")

In the next step, we will be creating a videoWriter object.
The video writer method of cv2 module needs 4 mandatory arguments.
First being the filename, second being the codec, third being the FPS (Frame per second) and the last being the video (or Screen) resolution. For a better screen recording 60 FPS is a good frame rate. You can experiment around the FPS value to get the optimum results.

out = cv2.VideoWriter("Recorded.avi", codec , 60, (1366, 768)) #Here screen resolution is 1366 x 768, you can change it depending upon your need

The next step is to implicitly create a window using namedWindow() method with the WINDOW_NORMAL flag so that the user can resize the window depending upon the need.

cv2.namedWindow("Recording", cv2.WINDOW_NORMAL)
cv2.resizeWindow("Recording", 480, 270) #Here we are resizing the window to 480x270 so that the program doesn't run in full screen in the beginning

Now we need to capture screenshot of each frame of the screen, write it to the video file and display the screen being recorded.
Here is the code snippet:

while True:
    img = pyautogui.screenshot() #capturing screenshot
    frame = np.array(img) #converting the image into numpy array representation 
    frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) #converting the BGR image into RGB image
    out.write(frame) #writing the RBG image to file
    cv2.imshow('Recording', frame) #display screen/frame being recorded
    if cv2.waitKey(1) == ord('q'): #Wait for the user to press 'q' key to stop the recording
        break

out.release() #closing the video file
cv2.destroyAllWindows() #destroying the recording window

Notice that the screenshot captured is in BGR format but in order to write the frame to the video file we need to convert it into RGB format using cvt.Color() method with COLOR_BGR2RBG flag. The condition if cv2.waitKey(1) == ord('q') waits for the user to press 'q' key to quit the recording. Lastly we have closed the video file and destroyed the recording window by release() and destroyAllWindows() method respectively.
PS. Linux users please don't be happy after hearing "Destroy all Windows" ;)

You are all done!
It's time to test the results.

Normal sized window :

Maximized window: (Horrible infinite loop)

Video Demonstration: // Detect dark theme var iframe = document.getElementById('tweet-1319363186101866496-667'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1319363186101866496&theme=dark" }

Thanks for reading!

Face Recognition in Python

Aditya Chaudhary👨‍💻 — Tue, 20 Oct 2020 09:34:44 +0000

In this article, we are going to take a look at how we can detect faces using Python and OpenCV.
To those who don't know what OpenCV is and what things it can do, must check out the previous post here.

OpenCV uses Machine Learning algorithms to detect faces. For a dumb machine like Computer, faces are too complex when represented in Computer understandable language. There is no simple test to detect faces. One has to match thousands of patterns. Using the divide and conquer rule these big processes are broken down into small task which is also known as Classifiers.

OpenCV uses cascades to detect faces. Cascades are nothing but a bunch of XML files that has all necessary OpenCV data to search for specific object in an image. OpenCV comes with built-in cascades for face-recognition but if you were to detect any other object you might have to create your own custom cascade. Creating custom cascade is a deep and complex process. Fortunately, we won't be going deep into it since we don't have to create any custom cascade for face detection.

To get started make sure you have OpenCV installed. To install OpenCV, type the following command in the terminal:
pip install opencv-python
If you don't encounter any problem while installing OpenCV, you can proceed to the next part.

The next step is to import OpenCV Module. This is how you can import the OpenCV module:

import cv2

In the next step, we have to read the image in which we want to detect the face. We also need to convert the image into a grayscale image since it is faster to do operations with grayscale images.

img = cv2.imread('man.png') # must pass valid file directory
gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  #converting the image into grayscale image

Next step is to initialize the Cascade Classifier. To do this you will need to download the haarcascade_frontalface_default.xml file from here

# Initializing the haar cascade
face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml")

The next step is the most important step in this process.

faces = face_cascade.detectMultiScale(gray_img, scaleFactor = 1.05, minNeighbors=5)

The detectMultiScale function detects the object. Here the first argument is the image itself (the grayscale image), second argument is scaleFactor which is mainly responsible to adjust some discrepancies. Some faces in the image can be small while some can be bigger and this is where scaleFactor plays its role. The algorithm requires a moving window to detect objects. minNeighbors defines how many objects are detected near the current one before it declares the face found.

Remember, all these values are generally used values. You might have to experiment around these values depending upon your need.

The next step is to draw a rectangle on the image with the help of the data in faces .

for x, y, w, h in faces:
    img = cv2.rectangle(img, (x,y), (x+w,y+h), (255, 255, 250),3)

Remember that we are drawing the rectangle on the original image and not on the grayscale image.

You are almost done!
Just display the image:

cv2.imshow("ImageWindow", img) # displaying the image
cv2.waitKey(0) #waitKey is set to 0, that means the image window will close as soon as any key is pressed.
cv2.destroyAllWindows()

Let's test the results!

Congratulations! You made the dumb machine to recognize a face!

OpenCV- An awesome tool for computer vision in python

Aditya Chaudhary👨‍💻 — Thu, 15 Oct 2020 07:28:28 +0000

To those who don't know what openCV is, it is a library for image/video processing, machine learning and computer vision. This tool also supports C++ and Java but I am little biased towards python and you all know the reason why.

Also, this is my first post on this platform since I am new here and in this post we are going to take a look at what this library is capable to do. Let's get started!

Image Processing : OpenCV is widely used for image processing and manipulations. The image is represented as a numpy array (3D array if RGB image is being read or 2D array if Grayscale image is being read). Face-recognition is the best example of things that OpenCV can do. From many useful tools to QR code reader, you can create literally tons of awesome project with it. Below is the video demonstration of simple QR code reader program that I made using openCV // Detect dark theme var iframe = document.getElementById('tweet-1315893570616717312-141'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1315893570616717312&theme=dark" }

By using various numpy methods you can experiment around the image properties like the specific color at any pixel/region. Below is a video demonstration of a simple color picker kind of program that opens an image and on left click, shows the hex color code of the area which is clicked and also copies the hex code to the clipboard!
// Detect dark theme var iframe = document.getElementById('tweet-1314804125721194496-81'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1314804125721194496&theme=dark" }

Video-Processing : A video is nothing but tons of frames of image. So basically things which you can do with image can also be done with video files. OpenCV provides you to read video from two streams. You can either pass your web cam as a video source and experiment around your camera properties or pass a valid file path of the compatible video file. One of the best projects which I saw on video-processing was Raghav Khanna's invisible cloak project. Here is the video demonstration of his project // Detect dark theme var iframe = document.getElementById('tweet-1285504929700777985-57'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1285504929700777985&theme=dark" }

Apart from these things openCV is widely used in game-automation, self-driving cars, smart CCTV cameras etc.

Now imagine if you have thousands of QR code images in your PC and you are given to draw the histogram graph of sites to which the different QR code belongs to. As a human being you can't scan each and every image to get the information about the QR code.
That's where programming and OpenCV plays key role.
Just crawl through that folder using os module, read and scan the image using OpenCV and by some algorithms plot a graph using matplotlib

Thanks for reading!