@strkfarm/sdk 1.0.17 → 1.0.19

package/src/dataTypes/_bignumber.ts

@@ -0,0 +1,53 @@
+import BigNumber from "bignumber.js";
+
+export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
+    decimals: number;
+
+    constructor(value: string | number, decimals: number) {
+        super(value);
+        this.decimals = decimals;
+    }
+
+    toWei() {
+        return this.mul(10 ** this.decimals).toFixed(0);
+    }
+
+    multipliedBy(value: string | number | T): T {
+        let _value = Number(value).toFixed(13);
+        return this.construct(this.mul(_value).toString(), this.decimals);
+    }
+
+    dividedBy(value: string | number | T): T {
+        let _value = Number(value).toFixed(13);
+        return this.construct(this.div(_value).toString(), this.decimals);
+    }
+
+    plus(value: string | number | T): T {
+        const _value = Number(value).toFixed(13);
+        return this.construct(this.add(_value).toString(), this.decimals);
+    }
+
+    minus(n: number | string | T, base?: number): T {
+        const _value = Number(n).toFixed(13);
+        return this.construct(super.minus(_value, base).toString(), this.decimals);
+    }
+
+    protected construct(value: string | number, decimals: number): T {
+        return new (this.constructor as { new (value: string | number, decimals: number): T })(value, decimals);
+    }
+
+    toString(base?: number | undefined): string {
+        return super.toString(base);
+    }
+    
+    toJSON() {
+        return this.toString();
+    }
+
+    valueOf() {
+        return this.toString();
+    }
+}
+
+BigNumber.config({ DECIMAL_PLACES: 18 })
+_Web3Number.config({ DECIMAL_PLACES: 18 })

package/src/dataTypes/address.ts

@@ -35,4 +35,8 @@ export class ContractAddr {
     static eqString(a: string, b: string) {
         return ContractAddr.standardise(a) === ContractAddr.standardise(b);
     }
+
+    toString() {
+        return this.address;
+    }
 }

package/src/dataTypes/bignumber.browser.ts

@@ -0,0 +1,8 @@
+import { _Web3Number } from "./_bignumber";
+
+export class Web3Number extends _Web3Number<Web3Number> {
+    static fromWei(weiNumber: string | number, decimals: number) {
+        const bn = (new Web3Number(weiNumber, decimals)).dividedBy(10 ** decimals)
+        return new Web3Number(bn.toString(), decimals);
+    }
+}

package/src/dataTypes/bignumber.node.ts

@@ -0,0 +1,22 @@
+import util from 'util';
+import { _Web3Number } from "./_bignumber";
+
+export class Web3Number extends _Web3Number<Web3Number> {
+
+    static fromWei(weiNumber: string | number, decimals: number) {
+        const bn = (new Web3Number(weiNumber, decimals)).dividedBy(10 ** decimals)
+        return new Web3Number(bn.toString(), decimals);
+    }
+
+    [util.inspect.custom](depth: any, opts: any): string {
+        return this.toString();
+    }
+
+    [Symbol.for('nodejs.util.inspect.custom')](depth: any, inspectOptions: any, inspect: any): string {
+        return this.toString();
+    }
+
+    inspect(depth: any, opts: any) {
+        return this.toString();
+    }
+}

package/src/dataTypes/bignumber.ts

@@ -1,55 +1 @@
-import BigNumber from "bignumber.js";
-// import { inspect } from 'util';
-// const customInspectSymbol = inspect.custom || Symbol.for('nodejs.util.inspect.custom');
-
-function isNode() {
-    // Check for the presence of the `window` object, which is undefined in Node.js
-    return typeof window === 'undefined';
-}
-
-export class Web3Number extends BigNumber {
-    decimals: number;
-
-    constructor(value: string | number, decimals: number) {
-        super(value);
-        this.decimals = decimals;
-    }
-
-    static fromWei(weiNumber: string | number, decimals: number) {
-        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: string | number) {
-        let _value = Number(value).toFixed(6);
-        return new Web3Number(this.mul(_value).toString(), this.decimals);
-    }
-
-    dividedBy(value: string | number) {
-        let _value = Number(value).toFixed(6);
-        return new Web3Number(this.div(_value).toString(), this.decimals);
-    }
-
-    plus(value: string | number) {
-        return new Web3Number(this.add(value).toString(), this.decimals);
-    }
-
-    minus(n: number | string, base?: number): Web3Number {
-        return new Web3Number(super.minus(n, base).toString(), this.decimals);
-    }
-
-    toString(base?: number | undefined): string {
-        return super.toString(base);
-    }
-    
-    // [customInspectSymbol](depth: any, inspectOptions: any, inspect: any) {
-    // return this.toString();
-    // }
-}
-
-BigNumber.config({ DECIMAL_PLACES: 18 })
-Web3Number.config({ DECIMAL_PLACES: 18 })
+export * from '@/dataTypes/bignumber.browser';

package/src/dataTypes/index.ts

@@ -1,2 +1,2 @@
-export * from './bignumber';
+export * from '@/dataTypes/bignumber';
 export * from './address';

package/src/global.ts

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { TokenInfo } from './interfaces';
+import { ContractAddr } from './dataTypes';
 
 const colors = {
     error: 'red',
@@ -45,14 +46,50 @@ export class FatalError extends Error {
     }
 }
 
-const tokens: TokenInfo[] = [{
+const defaultTokens: TokenInfo[] = [{
     name: 'Starknet',
     symbol: 'STRK',
     logo: 'https://assets.coingecko.com/coins/images/26433/small/starknet.png',
-    address: '0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',
+    address: ContractAddr.from('0x4718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d'),
     decimals: 18,
     coingeckId: 'starknet'
-}];
+}, {
+    name: 'xSTRK',
+    symbol: 'xSTRK',
+    logo: 'https://dashboard.endur.fi/endur-fi.svg',
+    address: ContractAddr.from('0x028d709c875c0ceac3dce7065bec5328186dc89fe254527084d1689910954b0a'),
+    decimals: 18,
+    coingeckId: undefined
+}, {
+    name: 'ETH',
+    symbol: 'ETH',
+    logo: 'https://opbnb.bscscan.com/token/images/ether.svg',
+    address: ContractAddr.from('0x49d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7'),
+    decimals: 18,
+    coingeckId: undefined
+}, {
+    name: 'USDC',
+    symbol: 'USDC',
+    logo: 'https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png',
+    address: ContractAddr.from('0x53c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8'),
+    decimals: 6,
+    coingeckId: undefined
+}, {
+    name: 'USDT',
+    symbol: 'USDT',
+    logo: 'https://assets.coingecko.com/coins/images/325/small/Tether.png',
+    address: ContractAddr.from('0x68f5c6a61780768455de69077e07e89787839bf8166decfbf92b645209c0fb8'),
+    decimals: 6,
+    coingeckId: undefined
+}, {
+    name: 'WBTC',
+    symbol: 'WBTC',
+    logo: 'https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/ethereum/assets/0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599/logo.png',
+    address: ContractAddr.from('0x3fe2b97c1fd336e750087d68b9b867997fd64a2661ff3ca5a7c771641e8e7ac'),
+    decimals: 8,
+    coingeckId: undefined
+}]
+const tokens: TokenInfo[] = defaultTokens;
 
 /** Contains globally useful functions. 
  * - fatalError: Things to do when a fatal error occurs
@@ -109,7 +146,7 @@ export class Global {
             tokens.push({
                 name: token.name,
                 symbol: token.symbol,
-                address: token.address,
+                address: ContractAddr.from(token.address),
                 decimals: token.decimals,
                 logo: token.logoUri,
                 coingeckId: token.extensions.coingeckoId,
@@ -124,4 +161,17 @@ export class Global {
             throw new FatalError(message);
         }
     }
+
+    static async getTokenInfoFromAddr(addr: ContractAddr) {
+        // if tokens are not loaded, load them
+        if (tokens.length == defaultTokens.length) {
+            await Global.getTokens();
+        }
+
+        const token = tokens.find((token) => addr.eq(token.address));
+        if (!token) {
+            throw new FatalError(`Token not found: ${addr.address}`);
+        }
+        return token;
+    }
 }

package/src/interfaces/common.ts

@@ -2,12 +2,18 @@ import { ContractAddr, Web3Number } from "@/dataTypes"
 import { BlockIdentifier, RpcProvider } from "starknet"
 
 export enum RiskType {
-    MARKET_RISK = 'MARKET_RISK',
-    IMPERMANENT_LOSS = 'IMPERMANENT_LOSS',
-    LIQUIDITY_RISK = 'LIQUIDITY_RISK',
-    SMART_CONTRACT_RISK = 'SMART_CONTRACT_RISK',
-    TECHNICAL_RISK = 'TECHNICAL_RISK',
-    COUNTERPARTY_RISK = 'COUNTERPARTY_RISK', // e.g. bad debt
+    MARKET_RISK = 'Market Risk',
+    // if non-correalted pairs, this is 3 (STRK/USDC)
+    // if highly correalted pairs, this is 1 (e.g. xSTRK/STRK)
+    // if correalted pairs, this is 2 (e.g. BTC/SOL)
+    // If there is added leverage on top, can go till 5
+    IMPERMANENT_LOSS = 'Impermanent Loss Risk',
+    LIQUIDATION_RISK = 'Liquidation Risk',
+    LOW_LIQUIDITY_RISK = 'Low Liquidity Risk',
+    SMART_CONTRACT_RISK = 'Smart Contract Risk',
+    ORACLE_RISK = 'Oracle Risk',
+    TECHNICAL_RISK = 'Technical Risk',
+    COUNTERPARTY_RISK = 'Counterparty Risk', // e.g. bad debt
 }
 
 export interface RiskFactor {
@@ -19,7 +25,7 @@ export interface RiskFactor {
 export interface TokenInfo {
     name: string,
     symbol: string,
-    address: string,
+    address: ContractAddr,
     decimals: number,
     logo: string,
     coingeckId?: string,
@@ -43,11 +49,17 @@ export interface IProtocol {
     logo: string,
 }
 
+export enum FlowChartColors {
+    Green = 'purple',
+    Blue = '#35484f',
+    Purple = '#6e53dc',
+}
+
 /**
  * @property risk.riskFactor.factor - The risk factors that are considered for the strategy.
  * @property risk.riskFactor.factor - The value of the risk factor from 0 to 10, 0 being the lowest and 10 being the highest.
  */
-export interface IStrategyMetadata {
+export interface IStrategyMetadata<T> {
     name: string,
     description: string,
     address: ContractAddr,
@@ -59,13 +71,15 @@ export interface IStrategyMetadata {
     risk: {
         riskFactor: RiskFactor[],
         netRisk: number
-    }
+    },
+    additionalInfo: T
 }
 
 export interface IInvestmentFlow {
     title: string,
-    subItems: string[],
+    subItems: {key: string, value: string}[],
     linkedFlows: IInvestmentFlow[],
+    style?: any
 }
 
 export function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blastapi.io", blockIdentifier: BlockIdentifier = 'pending'): IConfig {
@@ -77,4 +91,44 @@ export function getMainnetConfig(rpcUrl = "https://starknet-mainnet.public.blast
         stage: "production",
         network: Network.mainnet
     }
+}
+
+export const getRiskExplaination = (riskType: RiskType) => {
+    switch (riskType) {
+        case RiskType.MARKET_RISK:
+            return "The risk of the market moving against the position."
+        case RiskType.IMPERMANENT_LOSS:
+            return "The temporary loss of value experienced by liquidity providers in AMMs when asset prices diverge compared to simply holding them."
+        case RiskType.LIQUIDATION_RISK:
+            return "The risk of losing funds due to the position being liquidated."
+        case RiskType.LOW_LIQUIDITY_RISK:
+            return "The risk of low liquidity in the pool, which can lead to high slippages or reduced in-abilities to quickly exit the position."
+        case RiskType.ORACLE_RISK:
+            return "The risk of the oracle being manipulated or incorrect."
+        case RiskType.SMART_CONTRACT_RISK:
+            return "The risk of the smart contract being vulnerable to attacks."
+        case RiskType.TECHNICAL_RISK:
+            return "The risk of technical issues e.g. backend failure."
+        case RiskType.COUNTERPARTY_RISK:
+            return "The risk of the counterparty defaulting e.g. bad debt on lending platforms."
+    }
+}  
+
+export const getRiskColor = (risk: RiskFactor) => {
+    const value = risk.value;
+    if (value === 0) return 'green';
+    if (value < 2.5) return 'yellow';
+    return 'red';
+}
+
+export const getNoRiskTags = (risks: RiskFactor[]) => {
+    const noRisks1 = risks.filter(risk => risk.value === 0).map(risk => risk.type);
+
+    // const risks not present
+    const noRisks2 = Object.values(RiskType).filter(risk => !risks.map(risk => risk.type).includes(risk));
+
+    const mergedUnique = [...new Set([...noRisks1, ...noRisks2])];
+    
+    // add `No` to the start of each risk
+    return mergedUnique.map(risk => `No ${risk}`);
 }

package/src/interfaces/lending.ts

@@ -4,7 +4,7 @@ import { ContractAddr } from "@/dataTypes/address";
 import { loggers } from "winston";
 import { logger } from "@/global";
 import { log } from "console";
-import { Web3Number } from "@/dataTypes/bignumber";
+import { Web3Number } from "@/dataTypes";
 
 export interface ILendingMetadata {
     name: string;

package/src/modules/avnu.ts

@@ -0,0 +1,93 @@
+import { uint256 } from "starknet";
+
+import { Call, Uint256 } from "starknet";
+import { fetchBuildExecuteTransaction, fetchQuotes, Quote } from "@avnu/avnu-sdk";
+import { assert } from "../utils";
+
+export interface Route {
+    token_from: string,
+    token_to: string,
+    exchange_address: string,
+    percent: number,
+    additional_swap_params: string[]
+}
+
+export interface SwapInfo {
+    token_from_address: string, 
+    token_from_amount: Uint256, 
+    token_to_address: string,   
+    token_to_amount: Uint256, 
+    token_to_min_amount: Uint256,  
+    beneficiary: string,  
+    integrator_fee_amount_bps: number,
+    integrator_fee_recipient: string,
+    routes: Route[]
+}
+
+
+export class AvnuWrapper {
+    async getQuotes(
+        fromToken: string,
+        toToken: string,
+        amountWei: string,
+        taker: string,
+    ) {
+        const params: any = {
+            sellTokenAddress: fromToken,
+            buyTokenAddress: toToken,
+            sellAmount: amountWei,
+            takerAddress: taker,
+        };
+        assert(fromToken != toToken, 'From and to tokens are the same');
+
+        const quotes = await fetchQuotes(params);
+        assert(quotes.length > 0, 'No quotes found');
+        return quotes[0];
+    }
+
+    async getSwapInfo(
+        quote: Quote,
+        taker: string,
+        integratorFeeBps: number,
+        integratorFeeRecipient: string,
+        minAmount: string
+    ) {
+        const calldata = await  fetchBuildExecuteTransaction(quote.quoteId);
+        // its the multi swap function call
+        const call: Call = calldata.calls[1];
+        const callData: string[] = call.calldata as string[];
+        const routesLen: number = Number(callData[11]);
+        assert(routesLen > 0, 'No routes found');
+
+        // use call data to re-construct routes
+        let startIndex = 12;
+        const routes: Route[] = [];
+        for(let i=0; i<routesLen; ++i) {
+            const swap_params_len = Number(callData[startIndex + 4]);
+            const route: Route = {
+                token_from: callData[startIndex],
+                token_to: callData[startIndex + 1],
+                exchange_address: callData[startIndex + 2],
+                percent: Number(callData[startIndex + 3]),
+                additional_swap_params: swap_params_len > 0 ? callData.slice(startIndex + 5, startIndex + 5 + swap_params_len): []
+            }
+            routes.push(route);
+            startIndex += 5 + swap_params_len;
+        }
+
+        // swapInfo as expected by the strategy 
+        const swapInfo: SwapInfo = {
+            token_from_address: quote.sellTokenAddress, 
+            token_from_amount: uint256.bnToUint256(quote.sellAmount),
+            token_to_address: quote.buyTokenAddress,
+            token_to_amount: uint256.bnToUint256(quote.buyAmount), 
+            token_to_min_amount: uint256.bnToUint256(minAmount),
+            beneficiary: taker,
+            integrator_fee_amount_bps: integratorFeeBps,
+            integrator_fee_recipient: integratorFeeRecipient,
+            routes
+        };
+    
+        return swapInfo;
+    }
+}

package/src/modules/erc20.ts

@@ -0,0 +1,23 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig } from "@/interfaces";
+import { Contract } from "starknet";
+import ERC20Abi from '@/data/erc20.abi.json';
+
+export class ERC20 {
+    readonly config: IConfig;
+
+    constructor(config: IConfig) {
+        this.config = config;
+    }
+
+    contract(addr: string | ContractAddr) {
+        const _addr = typeof addr === 'string' ? addr : addr.address;
+        return new Contract(ERC20Abi, _addr, this.config.provider);
+    }
+
+    async balanceOf(token: string | ContractAddr, address: string | ContractAddr, tokenDecimals: number) {
+        const contract = this.contract(token);
+        const balance = await contract.call('balanceOf', [address.toString()]);
+        return Web3Number.fromWei(balance.toString(), tokenDecimals);
+    }
+}

package/src/modules/index.ts

@@ -2,3 +2,5 @@ export * from './pricer';
 export * from './pragma';
 export * from './zkLend';
 export * from './pricer-from-api';
+export * from './erc20';
+export * from './avnu';

package/src/modules/pricer.ts

@@ -183,7 +183,7 @@ export class Pricer extends PricerBase {
     }
 
     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 url = this.EKUBO_API.replace("{{TOKEN_ADDRESS}}", token.address.toString()).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));

package/src/modules/zkLend.ts

@@ -1,6 +1,6 @@
 import axios from "axios";
 import BigNumber from "bignumber.js";
-import { Web3Number } from "@/dataTypes/bignumber";
+import { Web3Number } from "@/dataTypes/bignumber.browser";
 import { FatalError, Global, logger } from "@/global";
 import { TokenInfo } from "@/interfaces";
 import { ILending, ILendingPosition, LendingToken, MarginType } from "@/interfaces/lending";
@@ -36,7 +36,7 @@ export class ZkLend extends ILending implements ILending {
                 const token: LendingToken = {
                     name: pool.token.name,
                     symbol: pool.token.symbol,
-                    address: savedTokenInfo?.address || '',
+                    address: savedTokenInfo?.address || ContractAddr.from(''),
                     logo: '',
                     decimals: pool.token.decimals,
                     borrowFactor: Web3Number.fromWei(pool.borrow_factor.value, pool.borrow_factor.decimals),

package/src/node/headless.browser.ts

@@ -0,0 +1,9 @@
+import axios from 'axios';
+
+export async function getAPIUsingHeadlessBrowser(
+    url: string
+) {
+    const res = await axios.get(url);
+    return res.data;
+}
+  

package/src/node/headless.node.ts

@@ -0,0 +1,36 @@
+const puppeteer = require('puppeteer');
+
+export async function getAPIUsingHeadlessBrowser(
+    url: string
+) {
+
+  try {
+    // Launch a headless browser
+    const browser = await puppeteer.launch({ headless: true });
+    const page = await browser.newPage();
+
+    // Set a realistic User-Agent to avoid suspicion
+    await page.setUserAgent(
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+    );
+
+    // Go to the API endpoint
+    await page.goto(url, {
+      waitUntil: 'networkidle2', // Wait until the page fully loads (including JS challenge)
+    });
+
+    // If the API returns JSON, extract it
+    const jsonData = await page.evaluate(() => {
+      const pre = document.querySelector('pre'); // Adjust based on how the API response is formatted
+      return pre && pre.textContent ? JSON.parse(pre.textContent) : null;
+    });
+
+    // Clean up
+    await browser.close();
+    return jsonData;
+  } catch (error) {
+    console.error('Error:', error);
+    return null;
+  }
+}
+  

package/src/node/headless.ts

@@ -0,0 +1 @@
+export * from './headless.browser';

package/src/node/index.ts

@@ -1 +1,2 @@
-export * from './pricer-redis';
+export * from './pricer-redis';
+export * from '@/node/headless';

package/src/strategies/base-strategy.ts

@@ -0,0 +1,47 @@
+import { ContractAddr, Web3Number } from "@/dataTypes";
+import { IConfig, TokenInfo } from "@/interfaces";
+import { Call } from "starknet";
+
+export interface SingleActionAmount {
+    tokenInfo: TokenInfo,
+    amount: Web3Number
+}
+
+export interface SingleTokenInfo extends SingleActionAmount {
+    usdValue: number
+};
+
+export interface DualActionAmount {
+    token0: SingleActionAmount,
+    token1: SingleActionAmount
+}
+export interface DualTokenInfo {
+    netUsdValue: number,
+    token0: SingleTokenInfo,
+    token1: SingleTokenInfo
+}
+
+export class BaseStrategy<TVLInfo, ActionInfo> {
+    readonly config: IConfig;
+
+    constructor(config: IConfig) {
+        this.config = config;
+    }
+
+    async getUserTVL(user: ContractAddr): Promise<TVLInfo> {
+        throw new Error("Not implemented");
+    }
+
+    async getTVL(): Promise<TVLInfo> {
+        throw new Error("Not implemented");
+    }   
+
+    depositCall(amountInfo: ActionInfo, receiver: ContractAddr): Call[] {
+        throw new Error("Not implemented");
+    }
+
+    withdrawCall(amountInfo: ActionInfo, receiver: ContractAddr, owner: ContractAddr): Call[] {
+        throw new Error("Not implemented");
+    }
+    
+}