@strkfarm/sdk 1.0.9 → 1.0.11

package/dist/index.mjs

@@ -6,90 +6,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/modules/pricer.ts
-import axios from "axios";
-
-// src/data/tokens.json
-var tokens_default = [
-  {
-    name: "Ether",
-    symbol: "ETH",
-    address: "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7",
-    decimals: 18,
-    pricerKey: "ETH-USDT"
-  },
-  {
-    name: "USD Coin",
-    symbol: "USDC",
-    address: "0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
-    decimals: 6,
-    pricerKey: "USDC-USDT"
-  },
-  {
-    name: "Wrapped BTC",
-    symbol: "WBTC",
-    address: "0x03fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac",
-    decimals: 8,
-    pricerKey: "WBTC-USDT"
-  },
-  {
-    name: "Tether USD",
-    symbol: "USDT",
-    address: "0x068f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8",
-    decimals: 6,
-    pricerKey: "USDT-USDT"
-  },
-  {
-    name: "Dai Stablecoin",
-    symbol: "DAIv0",
-    address: "",
-    decimals: 18,
-    pricerKey: "DAI-USDT"
-  },
-  {
-    name: "Starknet Wrapped Staked Ether",
-    symbol: "wstETH",
-    address: "0x042b8f0484674ca266ac5d08e4ac6a3fe65bd3129795def2dca5c34ecc5f96d2",
-    decimals: 18,
-    pricerKey: "wstETH-USDT"
-  },
-  {
-    name: "Starknet Token",
-    symbol: "STRK",
-    address: "0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d",
-    decimals: 18,
-    pricerKey: "STRK-USDT"
-  },
-  {
-    name: "zkLend Token",
-    symbol: "ZEND",
-    address: "",
-    decimals: 18,
-    pricerKey: "ZEND-USDT"
-  },
-  {
-    name: "Dai Stablecoin",
-    symbol: "DAI",
-    address: "",
-    decimals: 18,
-    pricerKey: "DAI-USDT"
-  },
-  {
-    name: "Ekubo Protocol",
-    symbol: "EKUBO",
-    address: "",
-    decimals: 18,
-    pricerKey: "DAI-USDT"
-  },
-  {
-    name: "kSTRK token",
-    symbol: "kSTRK",
-    address: "",
-    decimals: 18,
-    pricerKey: "DAI-USDT"
-  }
-];
+import axios2 from "axios";
 
 // src/global.ts
+import axios from "axios";
 var logger = {
   ...console,
   verbose(message) {
@@ -105,6 +25,7 @@ var FatalError = class extends Error {
     this.name = "FatalError";
   }
 };
+var tokens = [];
 var Global = class {
   static fatalError(message, err) {
     logger.error(message);
@@ -118,7 +39,23 @@ var Global = class {
     console.error(err);
   }
   static async getTokens() {
-    return tokens_default;
+    if (tokens.length) return tokens;
+    const data = await axios.get("https://starknet.api.avnu.fi/v1/starknet/tokens");
+    const tokensData = data.data.content;
+    tokensData.forEach((token) => {
+      if (!token.tags.includes("AVNU") || !token.tags.includes("Verified")) {
+        return;
+      }
+      tokens.push({
+        name: token.name,
+        symbol: token.symbol,
+        address: token.address,
+        decimals: token.decimals,
+        coingeckId: token.extensions.coingeckoId
+      });
+    });
+    console.log(tokens);
+    return tokens;
   }
   static assert(condition, message) {
     if (!condition) {
@@ -127,20 +64,89 @@ var Global = class {
   }
 };
 
+// src/dataTypes/bignumber.ts
+import BigNumber from "bignumber.js";
+var Web3Number = class _Web3Number extends BigNumber {
+  constructor(value, decimals) {
+    super(value);
+    this.decimals = decimals;
+  }
+  static fromWei(weiNumber, decimals) {
+    const bn = new _Web3Number(weiNumber, decimals).dividedBy(10 ** decimals);
+    return new _Web3Number(bn.toString(), decimals);
+  }
+  toWei() {
+    return this.mul(10 ** this.decimals).toFixed(0);
+  }
+  multipliedBy(value) {
+    return new _Web3Number(this.mul(value).toString(), this.decimals);
+  }
+  dividedBy(value) {
+    return new _Web3Number(this.div(value).toString(), this.decimals);
+  }
+  plus(value) {
+    return new _Web3Number(this.add(value).toString(), this.decimals);
+  }
+  minus(n, base) {
+    return new _Web3Number(super.minus(n, base).toString(), this.decimals);
+  }
+  toString(base) {
+    return super.toString(base);
+  }
+  // [customInspectSymbol](depth: any, inspectOptions: any, inspect: any) {
+  // return this.toString();
+  // }
+};
+BigNumber.config({ DECIMAL_PLACES: 18 });
+Web3Number.config({ DECIMAL_PLACES: 18 });
+
+// src/dataTypes/address.ts
+import { num } from "starknet";
+var ContractAddr = class _ContractAddr {
+  constructor(address) {
+    this.address = _ContractAddr.standardise(address);
+  }
+  static from(address) {
+    return new _ContractAddr(address);
+  }
+  eq(other) {
+    return this.address === other.address;
+  }
+  eqString(other) {
+    return this.address === _ContractAddr.standardise(other);
+  }
+  static standardise(address) {
+    let _a = address;
+    if (!address) {
+      _a = "0";
+    }
+    const a = num.getHexString(num.getDecimalString(_a.toString()));
+    return a;
+  }
+  static eqString(a, b) {
+    return _ContractAddr.standardise(a) === _ContractAddr.standardise(b);
+  }
+};
+
 // src/modules/pricer.ts
 var CoinMarketCap = __require("coinmarketcap-api");
 var Pricer = class {
-  constructor(config, tokens) {
+  constructor(config, tokens2) {
     this.tokens = [];
     this.prices = {};
+    // code populates this map during runtime to determine which method to use for a given token
+    // The method set will be the first one to try after first attempt
+    this.methodToUse = {};
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
      */
     this.PRICE_API = `https://api.coinbase.com/v2/prices/{{PRICER_KEY}}/buy`;
-    // backup oracle
+    this.EKUBO_API = "https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8";
+    // e.g. ETH/USDC
+    // backup oracle001
     this.client = new CoinMarketCap(process.env.COINMARKETCAP_KEY);
     this.config = config;
-    this.tokens = tokens;
+    this.tokens = tokens2;
   }
   isReady() {
     const allPricesExist = Object.keys(this.prices).length === this.tokens.length;
@@ -224,34 +230,72 @@ var Pricer = class {
     });
     if (this.isReady() && this.config.heartbeatUrl) {
       console.log(`sending beat`);
-      axios.get(this.config.heartbeatUrl).catch((err) => {
+      axios2.get(this.config.heartbeatUrl).catch((err) => {
         console.error("Pricer: Heartbeat err", err);
       });
     }
   }
-  async _getPrice(token) {
-    try {
-      return await this._getPriceCoinbase(token);
-    } catch (error) {
+  async _getPrice(token, defaultMethod = "all") {
+    const methodToUse = this.methodToUse[token.symbol] || defaultMethod;
+    logger.info(`Fetching price of ${token.symbol} using ${methodToUse}`);
+    switch (methodToUse) {
+      case "Coinbase":
+        try {
+          const result = await this._getPriceCoinbase(token);
+          this.methodToUse[token.symbol] = "Coinbase";
+          return result;
+        } catch (error) {
+          console.warn(`Coinbase: price err: message [${token.symbol}]: `, error.message);
+        }
+      case "Coinmarketcap":
+        try {
+          const result = await this._getPriceCoinMarketCap(token);
+          this.methodToUse[token.symbol] = "Coinmarketcap";
+          return result;
+        } catch (error) {
+          console.warn(`CoinMarketCap: price err [${token.symbol}]: `, Object.keys(error));
+          console.warn(`CoinMarketCap: price err [${token.symbol}]: `, error.message);
+        }
+      case "Ekubo":
+        try {
+          const result = await this._getPriceEkubo(token);
+          this.methodToUse[token.symbol] = "Ekubo";
+          return result;
+        } catch (error) {
+          console.warn(`Ekubo: price err [${token.symbol}]: `, error.message);
+          console.warn(`Ekubo: price err [${token.symbol}]: `, Object.keys(error));
+        }
     }
-    try {
-      return await this._getPriceCoinMarketCap(token);
-    } catch (error) {
+    if (defaultMethod == "all") {
+      return await this._getPrice(token, "Coinbase");
     }
-    throw new FatalError(`Price not found for ${token.name}`);
+    throw new FatalError(`Price not found for ${token.symbol}`);
   }
   async _getPriceCoinbase(token) {
-    if (!token.pricerKey) {
-      throw new FatalError(`Pricer key not found for ${token.name}`);
-    }
-    const url = this.PRICE_API.replace("{{PRICER_KEY}}", token.pricerKey);
-    const result = await axios.get(url);
+    const url = this.PRICE_API.replace("{{PRICER_KEY}}", `${token.symbol}-USD`);
+    const result = await axios2.get(url);
     const data = result.data;
     return Number(data.data.amount);
   }
   async _getPriceCoinMarketCap(token) {
     const result = await this.client.getQuotes({ symbol: token.symbol });
-    return result.data[token.symbol].quote.USD.price;
+    if (result.data)
+      return result.data[token.symbol].quote.USD.price;
+    throw new Error(result);
+  }
+  async _getPriceEkubo(token, amountIn = new Web3Number(1, token.decimals), retry = 0) {
+    const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address).replace("{{AMOUNT}}", amountIn.toWei());
+    const result = await axios2.get(url);
+    const data = result.data;
+    const outputUSDC = Number(Web3Number.fromWei(data.total_calculated, 6).toFixed(6));
+    logger.verbose(`Ekubo: ${token.symbol} -> USDC: ${outputUSDC}, retry: ${retry}`);
+    if (outputUSDC === 0 && retry < 3) {
+      const amountIn2 = new Web3Number(100, token.decimals);
+      return await this._getPriceEkubo(token, amountIn2, retry + 1);
+    }
+    const usdcPrice = (await this.getPrice("USDC")).price;
+    logger.verbose(`USDC Price: ${usdcPrice}`);
+    return outputUSDC * usdcPrice;
   }
 };
 
@@ -374,43 +418,7 @@ var Pragma = class {
 };
 
 // src/modules/zkLend.ts
-import axios2 from "axios";
-
-// src/dataTypes/bignumber.ts
-import BigNumber from "bignumber.js";
-var Web3Number = class _Web3Number extends BigNumber {
-  constructor(value, decimals) {
-    super(value);
-    this.decimals = decimals;
-  }
-  static fromWei(weiNumber, decimals) {
-    const bn = new _Web3Number(weiNumber, decimals).dividedBy(10 ** decimals);
-    return new _Web3Number(bn.toString(), decimals);
-  }
-  toWei() {
-    return this.mul(10 ** this.decimals).toFixed(0);
-  }
-  multipliedBy(value) {
-    return new _Web3Number(this.mul(value).toString(), this.decimals);
-  }
-  dividedBy(value) {
-    return new _Web3Number(this.div(value).toString(), this.decimals);
-  }
-  plus(value) {
-    return new _Web3Number(this.add(value).toString(), this.decimals);
-  }
-  minus(n, base) {
-    return new _Web3Number(super.minus(n, base).toString(), this.decimals);
-  }
-  toString(base) {
-    return super.toString(base);
-  }
-  // [customInspectSymbol](depth: any, inspectOptions: any, inspect: any) {
-  // return this.toString();
-  // }
-};
-BigNumber.config({ DECIMAL_PLACES: 18 });
-Web3Number.config({ DECIMAL_PLACES: 18 });
+import axios3 from "axios";
 
 // src/interfaces/lending.ts
 var MarginType = /* @__PURE__ */ ((MarginType2) => {
@@ -454,7 +462,7 @@ var _ZkLend = class _ZkLend extends ILending {
   async init() {
     try {
       logger.verbose(`Initialising ${this.metadata.name}`);
-      const result = await axios2.get(_ZkLend.POOLS_URL);
+      const result = await axios3.get(_ZkLend.POOLS_URL);
       const data = result.data;
       const savedTokens = await Global.getTokens();
       data.forEach((pool) => {
@@ -544,7 +552,7 @@ var _ZkLend = class _ZkLend extends ILending {
    */
   async getPositions(user) {
     const url = this.POSITION_URL.replace("{{USER_ADDR}}", user.address);
-    const result = await axios2.get(url);
+    const result = await axios3.get(url);
     const data = result.data;
     const lendingPosition = [];
     logger.verbose(`${this.metadata.name}:: Positions: ${JSON.stringify(data)}`);
@@ -613,34 +621,6 @@ var Initializable = class {
   }
 };
 
-// src/dataTypes/address.ts
-import { num } from "starknet";
-var ContractAddr = class _ContractAddr {
-  constructor(address) {
-    this.address = _ContractAddr.standardise(address);
-  }
-  static from(address) {
-    return new _ContractAddr(address);
-  }
-  eq(other) {
-    return this.address === other.address;
-  }
-  eqString(other) {
-    return this.address === _ContractAddr.standardise(other);
-  }
-  static standardise(address) {
-    let _a = address;
-    if (!address) {
-      _a = "0";
-    }
-    const a = num.getHexString(num.getDecimalString(_a.toString()));
-    return a;
-  }
-  static eqString(a, b) {
-    return _ContractAddr.standardise(a) === _ContractAddr.standardise(b);
-  }
-};
-
 // src/strategies/autoCompounderStrk.ts
 import { Contract as Contract2, uint256 } from "starknet";
 var AutoCompounderSTRK = class {
@@ -908,8 +888,8 @@ var Store = class _Store {
 // src/node/pricer-redis.ts
 import { createClient } from "redis";
 var PricerRedis = class extends Pricer {
-  constructor(config, tokens) {
-    super(config, tokens);
+  constructor(config, tokens2) {
+    super(config, tokens2);
     this.redisClient = null;
   }
   /** Reads prices from Pricer._loadPrices and uses a callback to set prices in redis */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "STRKFarm TS SDK (Meant for our internal use, but feel free to use it)",
   "typings": "dist/index.d.ts",
   "main": "dist/index.js",
@@ -53,6 +53,7 @@
     "inquirer": "^10.1.2",
     "node-telegram-bot-api": "^0.66.0",
     "redis": "^4.7.0",
+    "stacktrace-js": "^2.0.2",
     "starknet": "^6.11.0",
     "winston": "^3.13.0"
   }

package/src/global.ts

@@ -1,5 +1,5 @@
+import axios from 'axios';
 import { TokenInfo } from './interfaces';
-import TOKENS from '@/data/tokens.json';
 
 const colors = {
     error: 'red',
@@ -44,6 +44,9 @@ export class FatalError extends Error {
         this.name = "FatalError";
     }
 }
+
+const tokens: TokenInfo[] = [];
+
 /** Contains globally useful functions. 
  * - fatalError: Things to do when a fatal error occurs
  */
@@ -62,7 +65,46 @@ export class Global {
     }
 
     static async getTokens(): Promise<TokenInfo[]> {
-        return TOKENS;
+        if (tokens.length) return tokens;
+
+        // fetch from avnu API
+        const data = await axios.get('https://starknet.api.avnu.fi/v1/starknet/tokens');
+        const tokensData = data.data.content;
+
+        // Array of the following is returned
+        // {
+        //     "name": "USD Coin",
+        //     "address": "0x53c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8",
+        //     "symbol": "USDC",
+        //     "decimals": 6,
+        //     "logoUri": "https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png",
+        //     "lastDailyVolumeUsd": 2964287916.82621,
+        //     "extensions": {
+        //       "coingeckoId": "usd-coin"
+        //     },
+        //     "tags": [
+        //       "AVNU",
+        //       "Verified"
+        //     ]
+        // }
+
+        tokensData.forEach((token: any) => {
+            // if tags do not contain Avnu and verified, ignore
+            // This would exclude meme coins for now
+            if (!token.tags.includes('AVNU') || !token.tags.includes('Verified')) {
+                return;
+            }
+
+            tokens.push({
+                name: token.name,
+                symbol: token.symbol,
+                address: token.address,
+                decimals: token.decimals,
+                coingeckId: token.extensions.coingeckoId,
+            });
+        });
+        console.log(tokens);
+        return tokens;
     }
 
     static assert(condition: any, message: string) {

package/src/interfaces/common.ts

@@ -5,7 +5,7 @@ export interface TokenInfo {
     symbol: string,
     address: string,
     decimals: number,
-    pricerKey?: string
+    coingeckId?: string,
 }
 
 export enum Network {

package/src/modules/pricer.ts

@@ -2,6 +2,7 @@ import axios from "axios";
 import { FatalError, Global, logger } from "@/global";
 import { TokenInfo } from "@/interfaces/common";
 import { IConfig } from "@/interfaces/common";
+import { Web3Number } from "@/dataTypes";
 const CoinMarketCap = require('coinmarketcap-api')
 
 export interface PriceInfo {
@@ -15,14 +16,19 @@ export class Pricer {
         [key: string]: PriceInfo
     } = {}
 
+    // code populates this map during runtime to determine which method to use for a given token
+    // The method set will be the first one to try after first attempt
+    private methodToUse: {[tokenSymbol: string]: 'Ekubo' | 'Coinbase' | 'Coinmarketcap'} = {};
+
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
      */
     protected PRICE_API = `https://api.coinbase.com/v2/prices/{{PRICER_KEY}}/buy`;
-    
-    // backup oracle
+    protected EKUBO_API = 'https://quoter-mainnet-api.ekubo.org/{{AMOUNT}}/{{TOKEN_ADDRESS}}/0x053c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8'; // e.g. ETH/USDC
+
+    // backup oracle001
     protected client = new CoinMarketCap(process.env.COINMARKETCAP_KEY!);
- 
+    
     constructor(config: IConfig, tokens: TokenInfo[]) {
         this.config = config;
         this.tokens = tokens;
@@ -123,34 +129,81 @@ export class Pricer {
         }
     }
 
-    async _getPrice(token: TokenInfo) {
-        try {
-            return await this._getPriceCoinbase(token);
-        } catch (error) {
-            // do nothing, try next
+    async _getPrice(token: TokenInfo, defaultMethod = 'all'): Promise<number> {
+        const methodToUse: string = this.methodToUse[token.symbol] || defaultMethod; // default start with coinbase
+        logger.info(`Fetching price of ${token.symbol} using ${methodToUse}`);
+        switch (methodToUse) {
+            case 'Coinbase':
+                try {
+                    const result = await this._getPriceCoinbase(token);
+                    this.methodToUse[token.symbol] = 'Coinbase';
+                    return result;
+                } catch (error: any) {
+                    console.warn(`Coinbase: price err: message [${token.symbol}]: `, error.message);
+                    // do nothing, try next
+                }
+            case 'Coinmarketcap':
+                try {
+                    const result = await this._getPriceCoinMarketCap(token);
+                    this.methodToUse[token.symbol] = 'Coinmarketcap';
+                    return result;
+                } catch (error: any) {
+                    console.warn(`CoinMarketCap: price err [${token.symbol}]: `, Object.keys(error));
+                    console.warn(`CoinMarketCap: price err [${token.symbol}]: `, error.message);
+                }
+            case 'Ekubo':
+                try {
+                    const result = await this._getPriceEkubo(token);
+                    this.methodToUse[token.symbol] = 'Ekubo';
+                    return result;
+                } catch (error: any) {
+                    console.warn(`Ekubo: price err [${token.symbol}]: `, error.message);
+                    console.warn(`Ekubo: price err [${token.symbol}]: `, Object.keys(error));
+                    // do nothing, try next
+                }
         }
 
-        try {
-            return await this._getPriceCoinMarketCap(token);
-        } catch (error) {
-            // do nothing, try next
+        // if methodToUse is the default one, pass Coinbase to try all from start
+        if (defaultMethod == 'all') {
+            // try again with coinbase
+            return await this._getPrice(token, 'Coinbase');
         }
 
-        throw new FatalError(`Price not found for ${token.name}`);
+        throw new FatalError(`Price not found for ${token.symbol}`);
     }
 
     async _getPriceCoinbase(token: TokenInfo) {
-        if (!token.pricerKey) {
-            throw new FatalError(`Pricer key not found for ${token.name}`);
-        }
-        const url = this.PRICE_API.replace("{{PRICER_KEY}}", token.pricerKey);
-        const result = await axios.get(url);
+        const url = this.PRICE_API.replace("{{PRICER_KEY}}", `${token.symbol}-USD`);
+        const result = await axios.get(url)
         const data: any = result.data;
         return Number(data.data.amount);
     }
 
     async _getPriceCoinMarketCap(token: TokenInfo): Promise<number> {
         const result = await this.client.getQuotes({symbol: token.symbol});
-        return result.data[token.symbol].quote.USD.price as number
+        if (result.data)
+            return result.data[token.symbol].quote.USD.price as number
+
+        throw new Error(result);
+    }
+
+    async _getPriceEkubo(token: TokenInfo, amountIn = new Web3Number(1, token.decimals), retry = 0): Promise<number> {
+        const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address).replace("{{AMOUNT}}", amountIn.toWei());
+        const result = await axios.get(url);
+        const data: any = result.data;
+        const outputUSDC = Number(Web3Number.fromWei(data.total_calculated, 6).toFixed(6));
+        logger.verbose(`Ekubo: ${token.symbol} -> USDC: ${outputUSDC}, retry: ${retry}`);
+        if (outputUSDC === 0 && retry < 3) {
+            // try again with a higher amount
+            const amountIn = new Web3Number(100, token.decimals); // 100 unit of token
+            return await this._getPriceEkubo(token, amountIn, retry + 1);
+        }
+
+        // if usdc depegs, it will not longer be 1 USD
+        // so we need to get the price of USDC in USD
+        // and then convert the outputUSDC to USD
+        const usdcPrice = (await this.getPrice('USDC')).price;
+        logger.verbose(`USDC Price: ${usdcPrice}`);
+        return outputUSDC * usdcPrice;
     }
 }