@strkfarm/sdk 1.0.10 → 1.0.12

package/dist/index.browser.global.js

@@ -35038,11 +35038,14 @@ var strkfarm_risk_engine = (() => {
     constructor(config2, 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`;
-      this.EKUBO_API = "https://mainnet-api.ekubo.org/quote/{{AMOUNT}}/{{TOKEN_SYMBOL}}/USDC";
+      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);
@@ -35136,20 +35139,41 @@ var strkfarm_risk_engine = (() => {
         });
       }
     }
-    async _getPrice(token) {
-      try {
-        return await this._getPriceCoinbase(token);
-      } catch (error2) {
-      }
-      try {
-        return await this._getPriceCoinMarketCap(token);
-      } catch (error2) {
+    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 (error2) {
+            console.warn(`Coinbase: price err: message [${token.symbol}]: `, error2.message);
+          }
+        case "Coinmarketcap":
+          try {
+            const result = await this._getPriceCoinMarketCap(token);
+            this.methodToUse[token.symbol] = "Coinmarketcap";
+            return result;
+          } catch (error2) {
+            console.warn(`CoinMarketCap: price err [${token.symbol}]: `, Object.keys(error2));
+            console.warn(`CoinMarketCap: price err [${token.symbol}]: `, error2.message);
+          }
+        case "Ekubo":
+          try {
+            const result = await this._getPriceEkubo(token);
+            this.methodToUse[token.symbol] = "Ekubo";
+            return result;
+          } catch (error2) {
+            console.warn(`Ekubo: price err [${token.symbol}]: `, error2.message);
+            console.warn(`Ekubo: price err [${token.symbol}]: `, Object.keys(error2));
+          }
       }
-      try {
-        return await this._getPriceEkubo(token);
-      } catch (error2) {
+      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) {
       const url = this.PRICE_API.replace("{{PRICER_KEY}}", `${token.symbol}-USD`);
@@ -35159,19 +35183,21 @@ var strkfarm_risk_engine = (() => {
     }
     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_SYMBOL}}", token.symbol).replace("{{AMOUNT}}", amountIn.toWei());
+      const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address).replace("{{AMOUNT}}", amountIn.toWei());
       const result = await axios_default.get(url);
       const data = result.data;
-      const outputUSDC = Number(Web3Number.fromWei(data.total, 6).toFixed(6));
+      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;
+      const usdcPrice = 1;
       logger.verbose(`USDC Price: ${usdcPrice}`);
       return outputUSDC * usdcPrice;
     }

package/dist/index.d.ts

@@ -59,6 +59,7 @@ declare class Pricer {
     protected prices: {
         [key: string]: PriceInfo;
     };
+    private methodToUse;
     /**
      * TOKENA and TOKENB are the two token names to get price of TokenA in terms of TokenB
      */
@@ -73,7 +74,7 @@ declare class Pricer {
     assertNotStale(timestamp: Date, tokenName: string): void;
     getPrice(tokenName: string): Promise<PriceInfo>;
     protected _loadPrices(onUpdate?: (tokenSymbol: string) => void): void;
-    _getPrice(token: TokenInfo): Promise<number>;
+    _getPrice(token: TokenInfo, defaultMethod?: string): Promise<number>;
     _getPriceCoinbase(token: TokenInfo): Promise<number>;
     _getPriceCoinMarketCap(token: TokenInfo): Promise<number>;
     _getPriceEkubo(token: TokenInfo, amountIn?: Web3Number, retry?: number): Promise<number>;

package/dist/index.js

@@ -181,11 +181,14 @@ var Pricer = class {
   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`;
-    this.EKUBO_API = "https://mainnet-api.ekubo.org/quote/{{AMOUNT}}/{{TOKEN_SYMBOL}}/USDC";
+    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);
@@ -279,20 +282,41 @@ var Pricer = class {
       });
     }
   }
-  async _getPrice(token) {
-    try {
-      return await this._getPriceCoinbase(token);
-    } catch (error) {
-    }
-    try {
-      return await this._getPriceCoinMarketCap(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._getPriceEkubo(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) {
     const url = this.PRICE_API.replace("{{PRICER_KEY}}", `${token.symbol}-USD`);
@@ -302,19 +326,21 @@ var Pricer = class {
   }
   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_SYMBOL}}", token.symbol).replace("{{AMOUNT}}", amountIn.toWei());
+    const url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address).replace("{{AMOUNT}}", amountIn.toWei());
     const result = await import_axios2.default.get(url);
     const data = result.data;
-    const outputUSDC = Number(Web3Number.fromWei(data.total, 6).toFixed(6));
+    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;
+    const usdcPrice = 1;
     logger.verbose(`USDC Price: ${usdcPrice}`);
     return outputUSDC * usdcPrice;
   }

package/dist/index.mjs

@@ -134,11 +134,14 @@ var Pricer = class {
   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`;
-    this.EKUBO_API = "https://mainnet-api.ekubo.org/quote/{{AMOUNT}}/{{TOKEN_SYMBOL}}/USDC";
+    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);
@@ -232,20 +235,41 @@ var Pricer = class {
       });
     }
   }
-  async _getPrice(token) {
-    try {
-      return await this._getPriceCoinbase(token);
-    } catch (error) {
-    }
-    try {
-      return await this._getPriceCoinMarketCap(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._getPriceEkubo(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) {
     const url = this.PRICE_API.replace("{{PRICER_KEY}}", `${token.symbol}-USD`);
@@ -255,19 +279,21 @@ var Pricer = class {
   }
   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_SYMBOL}}", token.symbol).replace("{{AMOUNT}}", amountIn.toWei());
+    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, 6).toFixed(6));
+    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;
+    const usdcPrice = 1;
     logger.verbose(`USDC Price: ${usdcPrice}`);
     return outputUSDC * usdcPrice;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strkfarm/sdk",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "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/modules/pricer.ts

@@ -16,15 +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`;
-    protected EKUBO_API = 'https://mainnet-api.ekubo.org/quote/{{AMOUNT}}/{{TOKEN_SYMBOL}}/USDC'; // e.g. ETH/USDC
+    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;
@@ -125,45 +129,69 @@ export class Pricer {
         }
     }
 
-    async _getPrice(token: TokenInfo) {
-        try {
-            return await this._getPriceCoinbase(token);
-        } catch (error) {
-            // do nothing, try next
-        }
-
-        try {
-            return await this._getPriceCoinMarketCap(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._getPriceEkubo(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) {
         const url = this.PRICE_API.replace("{{PRICER_KEY}}", `${token.symbol}-USD`);
-        const result = await axios.get(url);
+        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_SYMBOL}}", token.symbol).replace("{{AMOUNT}}", amountIn.toWei());
+        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, 6).toFixed(6));
+        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
@@ -174,7 +202,7 @@ export class Pricer {
         // 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;
+        const usdcPrice = 1; // (await this.getPrice('USDC')).price;
         logger.verbose(`USDC Price: ${usdcPrice}`);
         return outputUSDC * usdcPrice;
     }