fix: Fix circulating supply API endpoint [DEV-1821]

src/api/bigDipperApi.ts

@@ -11,54 +11,6 @@ import { NodeApi } from './nodeApi';
 export class BigDipperApi {
   constructor(public readonly graphql_client: GraphQLClient) {}
 
-  async get_account(address: string): Promise<Account | null> {
-    let query = `query Account($address: String!, $where: vesting_account_bool_exp) {
-          accountBalance: action_account_balance(address: $address) {
-            coins
-          }
-          delegationBalance: action_delegation_total(address: $address) {
-            coins
-          }
-          unbondingBalance: action_unbonding_delegation_total(address: $address) {
-            coins
-          }
-          redelegationBalance: action_redelegation(address: $address) {
-            redelegations
-          }
-          rewardBalance: action_delegation_reward(address: $address) {
-            coins
-          }
-          vesting_account(where: $where) {
-            id
-            type
-            original_vesting
-            start_time
-            end_time
-          }
-        }`;
-
-    let params = {
-      address: address,
-      where: {
-        address: {
-          _eq: address,
-        },
-      },
-    };
-
-    try {
-      let resp = await this.graphql_client.query<{
-        data: any;
-        errors: any;
-      }>(query, params);
-
-      return resp.data as Account;
-    } catch (e: any) {
-      console.error(new Map(e));
-      return null;
-    }
-  }
-
   async get_total_supply(): Promise<Coin[]> {
     let query = `query Supply {
             supply(order_by: {height:desc} limit: 1) {

src/api/nodeApi.ts

@@ -1,4 +1,10 @@
-import { Account, Coin, ValidatorDetailResponse } from '../types/node';
+import {
+  Account,
+  Coin,
+  DelegationsResponse,
+  UnbondingResponse,
+  ValidatorDetailResponse,
+} from '../types/node';
 
 export class NodeApi {
   constructor(public readonly base_rest_api_url: string) {}
@@ -51,4 +57,40 @@ export class NodeApi {
 
     return await resp.json();
   }
+
+  async staking_get_all_delegations_for_delegator(
+    address: string,
+    next_key?: string
+  ) {
+    const resp = await fetch(
+      `${this.base_rest_api_url}/cosmos/staking/v1beta1/delegations/${address}${
+        next_key ? `?pagination.key=${next_key}` : ''
+      }`
+    );
+
+    return (await resp.json()) as DelegationsResponse;
+  }
+
+  async staking_get_all_unboding_delegations_for_delegator(
+    address: string,
+    next_key?: string
+  ) {
+    const resp = await fetch(
+      `${
+        this.base_rest_api_url
+      }/cosmos/staking/v1beta1/delegators/${address}/unbonding_delegations${
+        next_key ? `?pagination.key=${next_key}` : ''
+      }`
+    );
+
+    return (await resp.json()) as UnbondingResponse;
+  }
+
+  async get_latest_block_height(): Promise<number> {
+    const resp = await fetch(`${this.base_rest_api_url}/blocks/latest`);
+    let respJson = (await resp.json()) as {
+      block: { header: { height: number } };
+    };
+    return Number(respJson.block.header.height);
+  }
 }

src/bindings.d.ts

@@ -3,6 +3,7 @@ declare global {
   const REST_API: string;
   const GRAPHQL_API: string;
   const CIRCULATING_SUPPLY_WATCHLIST: KVNamespace;
+  const CIRCULATING_SUPPLY_GROUPS: number;
   const MARKET_MONITORING_API: string;
   const WEBHOOK_URL: string;
 }

src/handlers/circulatingSupply.ts

@@ -1,57 +1,46 @@
-import { GraphQLClient } from "../helpers/graphql";
-import { BigDipperApi } from "../api/bigDipperApi";
-import { Request } from "itty-router";
-import { ncheq_to_cheq_fixed } from "../helpers/currency";
-import { total_balance_ncheq } from "../helpers/node";
-import { Account } from "../types/bigDipper";
+import { Request } from 'itty-router';
+import { ncheq_to_cheq_fixed } from '../helpers/currency';
+import { NodeApi } from '../api/nodeApi';
+import { AccountBalanceInfos } from '../types/node';
+
+async function get_total_supply(): Promise<number> {
+  let node_api = new NodeApi(REST_API);
+  let total_supply_ncheq = await node_api.bank_get_total_supply_ncheq();
+  const total_supply = Number(ncheq_to_cheq_fixed(total_supply_ncheq));
+
+  return total_supply;
+}
 
 async function get_circulating_supply(): Promise<number> {
-    let gql_client = new GraphQLClient(GRAPHQL_API);
-    let bd_api = new BigDipperApi(gql_client);
-
-    let total_supply = await bd_api.get_total_supply();
-    let total_supply_ncheq = Number(total_supply.find(c => c.denom === "ncheq")?.amount || '0');
-
-    try {
-        const cached = await CIRCULATING_SUPPLY_WATCHLIST.list()
-        console.log(`found ${cached.keys.length} cached items`)
-
-        let non_circulating_supply_ncheq = Number(0);
-        for (const r of cached.keys) {
-            console.log(`looking for account: ${r.name} in cache`)
-            let data: any = await CIRCULATING_SUPPLY_WATCHLIST.get(r.name, { type: "json" });
-
-            if (data !== null) {
-                if (data.totalBalance === undefined) {
-                    const balance = total_balance_ncheq(JSON.parse(data) as Account)
-                    data = JSON.stringify({ totalBalance: balance, updatedAt: Date.now() })
-                    console.log(`updating bad cache entry: ${JSON.stringify(data)} totalBalance=${data.totalBalance} data=${JSON.stringify(data)}`)
-                    await CIRCULATING_SUPPLY_WATCHLIST.put(r.name, data)
-                }
-
-                console.log(`found cache entry: ${JSON.stringify(data)} totalBalance=${data.totalBalance}`)
-
-                if (data.totalBalance !== null) {
-                    non_circulating_supply_ncheq += data.totalBalance;
-                }
-            }
-        }
-
-        console.log(`Non-circulating supply: ${non_circulating_supply_ncheq}`);
-        // Get total supply
-        let total_supply_ncheq = Number(total_supply.find(c => c.denom === "ncheq")?.amount || '0');
-        console.log(`Total supply: ${total_supply_ncheq}`);
-
-        // Calculate circulating supply
-        return total_supply_ncheq - non_circulating_supply_ncheq;
-    } catch (e: any) {
-        console.error(new Map(e))
-        return total_supply_ncheq
+  const total_supply = await get_total_supply();
+
+  try {
+    const cached = await CIRCULATING_SUPPLY_WATCHLIST.list();
+    console.log(`Total cached entries: ${cached.keys.length}`);
+
+    let shareholders_total_balance = Number(0);
+    for (const key of cached.keys) {
+      let data: AccountBalanceInfos | null =
+        await CIRCULATING_SUPPLY_WATCHLIST.get(key.name, {
+          type: 'json',
+        });
+
+      if (data !== null && data.totalBalance !== null) {
+        shareholders_total_balance += Number(data.totalBalance);
+      }
     }
+
+    console.log('Total supply', total_supply);
+    console.log(`Watchlist total balance: ${shareholders_total_balance}`);
+
+    return total_supply - shareholders_total_balance;
+  } catch (e: any) {
+    throw new Error(e.toString);
+  }
 }
 
 export async function handler(request: Request): Promise<Response> {
-    let circulating_supply = await get_circulating_supply();
+  let circulating_supply = await get_circulating_supply();
 
-    return new Response(ncheq_to_cheq_fixed(circulating_supply));
+  return new Response(circulating_supply.toString());
 }

src/handlers/totalBalance.ts

@@ -1,50 +1,10 @@
 import { Request } from 'itty-router';
-import {
-  is_delayed_vesting_account_type,
-  validate_cheqd_address,
-} from '../helpers/validate';
-import { ncheq_to_cheq_fixed } from '../helpers/currency';
-import { BigDipperApi } from '../api/bigDipperApi';
-import { GraphQLClient } from '../helpers/graphql';
-import { total_balance_ncheq } from '../helpers/node';
-import { NodeApi } from '../api/nodeApi';
+import { get_account_balance_infos_from_node_api } from '../helpers/balance';
 
 export async function handler(request: Request): Promise<Response> {
   const address = request.params?.['address'];
-
-  if (!address || !validate_cheqd_address(address)) {
-    throw new Error('No address specified or wrong address format.');
-  }
-
-  let node_api = new NodeApi(REST_API);
-  let auth_account = await node_api.auth_get_account(address);
-
-  if (is_delayed_vesting_account_type(auth_account?.['@type'])) {
-    let balance = Number(
-      (await (
-        await node_api.bank_get_account_balances(address)
-      ).find((b) => b.denom === 'ncheq')?.amount) ?? '0'
-    );
-    let rewards = Number(
-      (await await node_api.distribution_get_total_rewards(address)) ?? '0'
-    );
-    let delegated = Number(
-      auth_account?.base_vesting_account?.delegated_vesting?.find(
-        (d) => d.denom === 'ncheq'
-      )?.amount ?? '0'
-    );
-
-    return new Response(ncheq_to_cheq_fixed(balance + rewards + delegated));
-  }
-
-  let gql_client = new GraphQLClient(GRAPHQL_API);
-  let bd_api = new BigDipperApi(gql_client);
-
-  let account = await bd_api.get_account(address);
-
-  if (!account) {
-    throw new Error('Account not found');
-  }
-
-  return new Response(ncheq_to_cheq_fixed(total_balance_ncheq(account)));
+  let account_balance_infos = await get_account_balance_infos_from_node_api(
+    address!!
+  );
+  return new Response(account_balance_infos?.totalBalance.toString());
 }

src/handlers/totalSupply.ts

@@ -1,10 +1,10 @@
-import { NodeApi } from "../api/nodeApi";
-import { Request } from "itty-router";
-import { ncheq_to_cheq_fixed } from "../helpers/currency";
+import { Request } from 'itty-router';
+import { NodeApi } from '../api/nodeApi';
+import { ncheq_to_cheq_fixed } from '../helpers/currency';
 
 export async function handler(request: Request): Promise<Response> {
-    let nodeApi = new NodeApi(REST_API);
-    let totalSupply = await nodeApi.bank_get_total_supply_ncheq();
+  let nodeApi = new NodeApi(REST_API);
+  let totalSupply = await nodeApi.bank_get_total_supply_ncheq();
 
-    return new Response(ncheq_to_cheq_fixed(totalSupply));
+  return new Response(ncheq_to_cheq_fixed(totalSupply));
 }

src/handlers/vestedBalance.ts

@@ -1,24 +1,29 @@
-import { Request } from "itty-router";
-import { is_vesting_account_type, validate_cheqd_address } from "../helpers/validate";
-import { NodeApi } from "../api/nodeApi";
-import { calculate_vested_coins } from "../helpers/vesting";
-import { ncheq_to_cheq_fixed } from "../helpers/currency";
+import { Request } from 'itty-router';
+import {
+  is_vesting_account_type,
+  validate_cheqd_address,
+} from '../helpers/validate';
+import { NodeApi } from '../api/nodeApi';
+import { calculate_vested_coins, estimatedVesting } from '../helpers/vesting';
+import { ncheq_to_cheq_fixed } from '../helpers/currency';
 
 export async function handler(request: Request): Promise<Response> {
-    const address = request.params?.['address'];
+  const address = request.params?.['address'];
 
-    if (!address || !validate_cheqd_address(address)) {
-        throw new Error("No address specified or wrong address format.");
-    }
+  if (!address || !validate_cheqd_address(address)) {
+    throw new Error('No address specified or wrong address format.');
+  }
 
-    let api = new NodeApi(REST_API);
-    const account = await api.auth_get_account(address);
+  let api = new NodeApi(REST_API);
+  const account = await api.auth_get_account(address);
 
-    if (!is_vesting_account_type(account["@type"])) {
-        throw new Error(`Only vesting accounts are supported. Accounts type '${account["@type"]}'.`)
-    }
+  if (!is_vesting_account_type(account['@type'])) {
+    throw new Error(
+      `Only vesting accounts are supported. Accounts type '${account['@type']}'.`
+    );
+  }
 
-    let vested_coins = calculate_vested_coins(account);
+  let vested_coins = estimatedVesting(account)?.vested;
 
-    return new Response(ncheq_to_cheq_fixed(vested_coins));
+  return new Response(ncheq_to_cheq_fixed(vested_coins!!));
 }

src/handlers/vestingBalance.ts

@@ -1,24 +1,29 @@
-import { Request } from "itty-router";
-import { is_vesting_account_type, validate_cheqd_address } from "../helpers/validate";
-import { NodeApi } from "../api/nodeApi";
-import { calculate_vesting_coins } from "../helpers/vesting";
-import { ncheq_to_cheq_fixed } from "../helpers/currency";
+import { Request } from 'itty-router';
+import {
+  is_vesting_account_type,
+  validate_cheqd_address,
+} from '../helpers/validate';
+import { NodeApi } from '../api/nodeApi';
+import { calculate_vesting_coins, estimatedVesting } from '../helpers/vesting';
+import { ncheq_to_cheq_fixed } from '../helpers/currency';
 
 export async function handler(request: Request): Promise<Response> {
-    const address = request.params?.['address'];
+  const address = request.params?.['address'];
 
-    if (!address || !validate_cheqd_address(address)) {
-        throw new Error("No address specified or wrong address format.");
-    }
+  if (!address || !validate_cheqd_address(address)) {
+    throw new Error('No address specified or wrong address format.');
+  }
 
-    let api = new NodeApi(REST_API);
-    const account = await api.auth_get_account(address)
+  let api = new NodeApi(REST_API);
+  const account = await api.auth_get_account(address);
 
-    if (!is_vesting_account_type(account["@type"])) {
-        throw new Error(`Only vesting accounts are supported. Accounts type '${account["@type"]}'.`)
-    }
+  if (!is_vesting_account_type(account['@type'])) {
+    throw new Error(
+      `Only vesting accounts are supported. Accounts type '${account['@type']}'.`
+    );
+  }
 
-    let vestingCoins = calculate_vesting_coins(account);
+  let vestingCoins = estimatedVesting(account)?.vesting;
 
-    return new Response(ncheq_to_cheq_fixed(vestingCoins));
+  return new Response(ncheq_to_cheq_fixed(vestingCoins!!));
 }

src/handlers/webhookTriggers.ts

@@ -1,8 +1,10 @@
+import { updateGroupBalances } from '../helpers/balanceGroup';
 import { filterArbitrageOpportunities } from './arbitrageOpportunities';
 
 export async function webhookTriggers(event: Event) {
   console.log('Triggering webhook...');
   await sendPriceDiscrepancies();
+  await updateGroupBalances(getRandomGroup());
 }
 
 export async function sendPriceDiscrepancies() {
@@ -29,3 +31,9 @@ export async function sendPriceDiscrepancies() {
     }
   }
 }
+
+function getRandomGroup(): number {
+  let min = 1;
+  let max = Math.floor(CIRCULATING_SUPPLY_GROUPS);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}