@strkfarm/sdk 1.0.9 → 1.0.11

package/dist/index.d.ts

@@ -8,7 +8,7 @@ interface TokenInfo {
     symbol: string;
     address: string;
     decimals: number;
-    pricerKey?: string;
+    coingeckId?: string;
 }
 declare enum Network {
     mainnet = "mainnet",
@@ -23,6 +23,32 @@ interface IConfig {
 }
 declare function getMainnetConfig(rpcUrl?: string, blockIdentifier?: BlockIdentifier): IConfig;
 
+declare class Web3Number extends BigNumber {
+    decimals: number;
+    constructor(value: string | number, decimals: number);
+    static fromWei(weiNumber: string | number, decimals: number): Web3Number;
+    toWei(): string;
+    multipliedBy(value: string | number): Web3Number;
+    dividedBy(value: string | number): Web3Number;
+    plus(value: string | number): Web3Number;
+    minus(n: number | string, base?: number): Web3Number;
+    toString(base?: number | undefined): string;
+}
+
+/**
+ * A simple wrapper around a contract address that is universally comparable
+ * - Helps avoid padding issues
+ */
+declare class ContractAddr {
+    readonly address: string;
+    constructor(address: string);
+    static from(address: string): ContractAddr;
+    eq(other: ContractAddr): boolean;
+    eqString(other: string): boolean;
+    static standardise(address: string | bigint): string;
+    static eqString(a: string, b: string): boolean;
+}
+
 interface PriceInfo {
     price: number;
     timestamp: Date;
@@ -33,10 +59,12 @@ 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
      */
     protected PRICE_API: string;
+    protected EKUBO_API: string;
     protected client: any;
     constructor(config: IConfig, tokens: TokenInfo[]);
     isReady(): boolean;
@@ -46,9 +74,10 @@ 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>;
 }
 
 declare class Pragma {
@@ -58,32 +87,6 @@ declare class Pragma {
     getPrice(tokenAddr: string): Promise<number>;
 }
 
-/**
- * A simple wrapper around a contract address that is universally comparable
- * - Helps avoid padding issues
- */
-declare class ContractAddr {
-    readonly address: string;
-    constructor(address: string);
-    static from(address: string): ContractAddr;
-    eq(other: ContractAddr): boolean;
-    eqString(other: string): boolean;
-    static standardise(address: string | bigint): string;
-    static eqString(a: string, b: string): boolean;
-}
-
-declare class Web3Number extends BigNumber {
-    decimals: number;
-    constructor(value: string | number, decimals: number);
-    static fromWei(weiNumber: string | number, decimals: number): Web3Number;
-    toWei(): string;
-    multipliedBy(value: string | number): Web3Number;
-    dividedBy(value: string | number): Web3Number;
-    plus(value: string | number): Web3Number;
-    minus(n: number | string, base?: number): Web3Number;
-    toString(base?: number | undefined): string;
-}
-
 interface ILendingMetadata {
     name: string;
     logo: string;

package/dist/index.js

@@ -53,90 +53,10 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/modules/pricer.ts
-var import_axios = __toESM(require("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"
-  }
-];
+var import_axios2 = __toESM(require("axios"));
 
 // src/global.ts
+var import_axios = __toESM(require("axios"));
 var logger = {
   ...console,
   verbose(message) {
@@ -152,6 +72,7 @@ var FatalError = class extends Error {
     this.name = "FatalError";
   }
 };
+var tokens = [];
 var Global = class {
   static fatalError(message, err) {
     logger.error(message);
@@ -165,7 +86,23 @@ var Global = class {
     console.error(err);
   }
   static async getTokens() {
-    return tokens_default;
+    if (tokens.length) return tokens;
+    const data = await import_axios.default.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) {
@@ -174,20 +111,89 @@ var Global = class {
   }
 };
 
+// src/dataTypes/bignumber.ts
+var import_bignumber = __toESM(require("bignumber.js"));
+var Web3Number = class _Web3Number extends import_bignumber.default {
+  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();
+  // }
+};
+import_bignumber.default.config({ DECIMAL_PLACES: 18 });
+Web3Number.config({ DECIMAL_PLACES: 18 });
+
+// src/dataTypes/address.ts
+var import_starknet = require("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 = import_starknet.num.getHexString(import_starknet.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;
@@ -271,39 +277,77 @@ var Pricer = class {
     });
     if (this.isReady() && this.config.heartbeatUrl) {
       console.log(`sending beat`);
-      import_axios.default.get(this.config.heartbeatUrl).catch((err) => {
+      import_axios2.default.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 import_axios.default.get(url);
+    const url = this.PRICE_API.replace("{{PRICER_KEY}}", `${token.symbol}-USD`);
+    const result = await import_axios2.default.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 import_axios2.default.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;
   }
 };
 
 // src/modules/pragma.ts
-var import_starknet = require("starknet");
+var import_starknet2 = require("starknet");
 
 // src/data/pragma.abi.json
 var pragma_abi_default = [
@@ -407,7 +451,7 @@ var pragma_abi_default = [
 var Pragma = class {
   constructor(provider) {
     this.contractAddr = "0x023fb3afbff2c0e3399f896dcf7400acf1a161941cfb386e34a123f228c62832";
-    this.contract = new import_starknet.Contract(pragma_abi_default, this.contractAddr, provider);
+    this.contract = new import_starknet2.Contract(pragma_abi_default, this.contractAddr, provider);
   }
   async getPrice(tokenAddr) {
     if (!tokenAddr) {
@@ -421,43 +465,7 @@ var Pragma = class {
 };
 
 // src/modules/zkLend.ts
-var import_axios2 = __toESM(require("axios"));
-
-// src/dataTypes/bignumber.ts
-var import_bignumber = __toESM(require("bignumber.js"));
-var Web3Number = class _Web3Number extends import_bignumber.default {
-  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();
-  // }
-};
-import_bignumber.default.config({ DECIMAL_PLACES: 18 });
-Web3Number.config({ DECIMAL_PLACES: 18 });
+var import_axios3 = __toESM(require("axios"));
 
 // src/interfaces/lending.ts
 var MarginType = /* @__PURE__ */ ((MarginType2) => {
@@ -501,7 +509,7 @@ var _ZkLend = class _ZkLend extends ILending {
   async init() {
     try {
       logger.verbose(`Initialising ${this.metadata.name}`);
-      const result = await import_axios2.default.get(_ZkLend.POOLS_URL);
+      const result = await import_axios3.default.get(_ZkLend.POOLS_URL);
       const data = result.data;
       const savedTokens = await Global.getTokens();
       data.forEach((pool) => {
@@ -591,7 +599,7 @@ var _ZkLend = class _ZkLend extends ILending {
    */
   async getPositions(user) {
     const url = this.POSITION_URL.replace("{{USER_ADDR}}", user.address);
-    const result = await import_axios2.default.get(url);
+    const result = await import_axios3.default.get(url);
     const data = result.data;
     const lendingPosition = [];
     logger.verbose(`${this.metadata.name}:: Positions: ${JSON.stringify(data)}`);
@@ -624,7 +632,7 @@ _ZkLend.POOLS_URL = "https://app.zklend.com/api/pools";
 var ZkLend = _ZkLend;
 
 // src/interfaces/common.ts
-var import_starknet2 = require("starknet");
+var import_starknet3 = require("starknet");
 var Network = /* @__PURE__ */ ((Network2) => {
   Network2["mainnet"] = "mainnet";
   Network2["sepolia"] = "sepolia";
@@ -633,7 +641,7 @@ var Network = /* @__PURE__ */ ((Network2) => {
 })(Network || {});
 function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io", blockIdentifier = "pending") {
   return {
-    provider: new import_starknet2.RpcProvider({
+    provider: new import_starknet3.RpcProvider({
       nodeUrl: rpcUrl,
       blockIdentifier
     }),
@@ -660,34 +668,6 @@ var Initializable = class {
   }
 };
 
-// src/dataTypes/address.ts
-var import_starknet3 = require("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 = import_starknet3.num.getHexString(import_starknet3.num.getDecimalString(_a.toString()));
-    return a;
-  }
-  static eqString(a, b) {
-    return _ContractAddr.standardise(a) === _ContractAddr.standardise(b);
-  }
-};
-
 // src/strategies/autoCompounderStrk.ts
 var import_starknet4 = require("starknet");
 var AutoCompounderSTRK = class {
@@ -955,8 +935,8 @@ var Store = class _Store {
 // src/node/pricer-redis.ts
 var import_redis = require("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 */