@strkfarm/sdk 2.0.0-dev.4 → 2.0.0-dev.40

package/src/data/universal-vault.abi.json

@@ -1628,32 +1628,32 @@
       {
         "name": "ERC20Event",
         "type": "openzeppelin_token::erc20::erc20::ERC20Component::Event",
-        "kind": "nested"
+        "kind": "flat"
       },
       {
         "name": "ERC4626Event",
         "type": "openzeppelin_token::erc20::extensions::erc4626::erc4626::ERC4626Component::Event",
-        "kind": "nested"
+        "kind": "flat"
       },
       {
         "name": "SRC5Event",
         "type": "openzeppelin_introspection::src5::SRC5Component::Event",
-        "kind": "nested"
+        "kind": "flat"
       },
       {
         "name": "AccessControlEvent",
         "type": "openzeppelin_access::accesscontrol::accesscontrol::AccessControlComponent::Event",
-        "kind": "nested"
+        "kind": "flat"
       },
       {
         "name": "UpgradeableEvent",
         "type": "openzeppelin_upgrades::upgradeable::UpgradeableComponent::Event",
-        "kind": "nested"
+        "kind": "flat"
       },
       {
         "name": "PausableEvent",
         "type": "openzeppelin_security::pausable::PausableComponent::Event",
-        "kind": "nested"
+        "kind": "flat"
       },
       {
         "name": "RedeemRequested",
@@ -1677,4 +1677,5 @@
       }
     ]
   }
-]
+]
+

package/src/dataTypes/_bignumber.ts

@@ -1,5 +1,6 @@
 import { logger } from "@/utils/logger";
 import BigNumber from "bignumber.js";
+import { uint256 } from "starknet";
 
 export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
   decimals: number;
@@ -26,11 +27,11 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
   plus(value: string | number | T): T {
     // Convert to raw number/string to avoid calling overridden methods
     const rawValue = this.getStandardString(value);
-    
+
     // Create a fresh BigNumber instance to do the math
     const thisBN = new BigNumber(this.toString());
     const result = thisBN.plus(rawValue);
-    
+
     return this.construct(result.toString(), this.decimals);
     // const _value = this.getStandardString(value);
     // return this.construct(super.plus(_value).toString(), this.decimals);
@@ -38,11 +39,11 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
 
   minus(n: number | string | T, base?: number): T {
     const rawValue = this.getStandardString(n);
-  
+
     // Create a fresh BigNumber instance to do the math
     const thisBN = new BigNumber(this.toString());
     const result = thisBN.minus(rawValue, base);
-    
+
     return this.construct(result.toString(), this.decimals);
     // const _value = this.getStandardString(n);
     // return this.construct(super.minus(_value, base).toString(), this.decimals);
@@ -100,6 +101,10 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
     return this.construct(Math.abs(this.toNumber()).toFixed(12), this.decimals);
   }
 
+  toFixedRoundDown(dp?: number): string {
+    return this.toFixed(dp, BigNumber.ROUND_DOWN);
+  }
+
   toI129(): { mag: bigint, sign: 0 | 1 } {
     const sign = this.isNegative() ? 1 : 0;
     return {
@@ -107,6 +112,10 @@ export class _Web3Number<T extends _Web3Number<T>> extends BigNumber {
       sign: sign,
     }
   }
+
+  toUint256() {
+    return uint256.bnToUint256(this.toWei());
+  }
 }
 
 BigNumber.config({ DECIMAL_PLACES: 18, ROUNDING_MODE: BigNumber.ROUND_DOWN });

package/src/dataTypes/bignumber.browser.ts

@@ -1,3 +1,4 @@
+import { Uint256, uint256 } from "starknet";
 import { _Web3Number } from "./_bignumber";
 
 export class Web3Number extends _Web3Number<Web3Number> {
@@ -5,4 +6,12 @@ export class Web3Number extends _Web3Number<Web3Number> {
         const bn = (new Web3Number(weiNumber, decimals)).dividedBy(10 ** decimals)
         return new Web3Number(bn.toString(), decimals);
     }
-}
+
+    static fromNumber(number: number, decimals: number) {
+        return new Web3Number(number.toString(), decimals);
+    }
+
+    static fromUint256(uint256Value: Uint256): Web3Number {
+        return this.fromWei(uint256.uint256ToBN(uint256Value).toString(), 18);
+    }
+}

package/src/dataTypes/bignumber.node.ts

@@ -1,5 +1,6 @@
 import util from 'util';
 import { _Web3Number } from "./_bignumber";
+import { Uint256, uint256 } from 'starknet';
 
 export class Web3Number extends _Web3Number<Web3Number> {
 
@@ -8,6 +9,14 @@ export class Web3Number extends _Web3Number<Web3Number> {
         return new Web3Number(bn.toString(), decimals);
     }
 
+    static fromNumber(number: number, decimals: number) {
+        return new Web3Number(number.toString(), decimals);
+    }
+
+    static fromUint256(uint256Value: Uint256): Web3Number {
+        return this.fromWei(uint256.uint256ToBN(uint256Value).toString(), 18);
+    }
+
     [util.inspect.custom](depth: any, opts: any): string {
         return this.toString();
     }
@@ -19,4 +28,4 @@ export class Web3Number extends _Web3Number<Web3Number> {
     inspect(depth: any, opts: any) {
         return this.toString();
     }
-}
+}

package/src/dataTypes/index.ts

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

package/src/dataTypes/mynumber.ts

@@ -0,0 +1,141 @@
+import BigNumber from "bignumber.js";
+import { ethers } from "ethers";
+
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+
+BigNumber.config({
+    DECIMAL_PLACES: 18
+});
+
+export class MyNumber {
+    bigNumber: BigNumber;
+    decimals: number;
+
+    constructor(bigNumber: string, decimals: number) {
+        this.bigNumber = new BigNumber(bigNumber);
+        this.decimals = decimals;
+    }
+
+    static fromEther(num: string, decimals: number) {
+        try {
+            return new MyNumber(
+                Number(
+                    ethers.parseUnits(Number(num).toFixed(10), decimals)
+                ).toFixed(6),
+                decimals
+            );
+        } catch (e) {
+            console.error("fromEther", e, num, decimals);
+            throw e;
+        }
+    }
+
+    static fromZero() {
+        return new MyNumber("0", 0);
+    }
+
+    toString() {
+        return this.bigNumber.toFixed();
+    }
+
+    toEtherStr() {
+        return ethers.formatUnits(this.bigNumber.toFixed(), this.decimals);
+    }
+
+    toFixedStr(decimals: number) {
+        return Number(this.toEtherStr()).toFixed(decimals);
+    }
+
+    toEtherToFixedDecimals(decimals: number) {
+        // rounding down
+        if (this.bigNumber.isNaN()) {
+            return "NaN";
+        }
+        return (
+            Math.floor(parseFloat(this.toEtherStr()) * 10 ** decimals) /
+            10 ** decimals
+        ).toFixed(decimals);
+    }
+
+    isZero() {
+        return this.bigNumber.eq("0");
+    }
+
+    /**
+     *
+     * @param amountEther in token terms without decimal e.g. 1 for 1 STRK
+     * @param command BigNumber compare funds. e.g. gte, gt, lt
+     * @returns
+     * @dev Add more commands as needed
+     */
+    compare(amountEther: string, command: "gte" | "gt" | "lt") {
+        const fullNum = new BigNumber(
+            ethers.parseUnits(amountEther, this.decimals).toString()
+        );
+        return this.bigNumber[command](fullNum);
+    }
+
+    operate(command: "div" | "plus" | "mul", value: string | number) {
+        const bn = new BigNumber(Number(value).toFixed(6));
+        return new MyNumber(
+            this.bigNumber[command](bn).toFixed(0),
+            this.decimals
+        );
+    }
+
+    subtract(value: MyNumber) {
+        const bn = this.bigNumber.minus(value.bigNumber);
+        return new MyNumber(bn.toString(), this.decimals);
+    }
+
+    static min(a: MyNumber, b: MyNumber) {
+        if (a.decimals !== b.decimals) {
+            const diff = Math.abs(a.decimals - b.decimals);
+            if (a.decimals > b.decimals) {
+                b = new MyNumber(
+                    b.bigNumber.times(10 ** diff).toString(),
+                    a.decimals
+                );
+            } else {
+                a = new MyNumber(
+                    a.bigNumber.times(10 ** diff).toString(),
+                    b.decimals
+                );
+            }
+        }
+        const bn = BigNumber.min(a.bigNumber, b.bigNumber);
+        return new MyNumber(
+            bn.toString(),
+            a.decimals > b.decimals ? a.decimals : b.decimals
+        );
+    }
+
+    static max(a: MyNumber, b: MyNumber) {
+        if (a.decimals !== b.decimals) {
+            const diff = Math.abs(a.decimals - b.decimals);
+            if (a.decimals > b.decimals) {
+                b = new MyNumber(
+                    b.bigNumber.times(10 ** diff).toString(),
+                    a.decimals
+                );
+            } else {
+                a = new MyNumber(
+                    a.bigNumber.times(10 ** diff).toString(),
+                    b.decimals
+                );
+            }
+        }
+        const bn = BigNumber.max(a.bigNumber, b.bigNumber);
+        return new MyNumber(
+            bn.toString(),
+            a.decimals > b.decimals ? a.decimals : b.decimals
+        );
+    }
+
+    [customInspectSymbol](depth: any, inspectOptions: any, inspect: any) {
+        return JSON.stringify({
+            raw: this.toString(),
+            decimals: this.decimals
+        });
+    }
+}

package/src/global.ts

@@ -48,14 +48,21 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     priceCheckAmount: 0.1,
     displayDecimals: 6,
-  },
-  {
-    name: "USDCe",
-    symbol: "USDCe",
-    logo: "https://assets.troves.fi/integrations/tokens/usdc.svg",
-    address: ContractAddr.from(
-      "0x53c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8"
-    ),
+}, {
+    name: 'USDC.e',
+    symbol: 'USDC.e',
+    logo: 'https://assets.troves.fi/integrations/tokens/usdc.svg',
+    address: ContractAddr.from('0x53c91253bc9682c04929ca02ed00b3e423f6710d2ee7e0d5ebb06f3ecf368a8'),
+    decimals: 6,
+    coingeckId: undefined,
+    displayDecimals: 2,
+    priceCheckAmount: 1000,
+    priceProxySymbol: 'USDC'
+}, {
+    name: 'USDC',
+    symbol: 'USDC',
+    logo: 'https://assets.troves.fi/integrations/tokens/usdc.svg',
+    address: ContractAddr.from('0x033068F6539f8e6e6b131e6B2B814e6c34A5224bC66947c47DaB9dFeE93b35fb'),
     decimals: 6,
     coingeckId: undefined,
     displayDecimals: 2,
@@ -133,6 +140,7 @@ const defaultTokens: TokenInfo[] = [
     decimals: 8,
     coingeckId: undefined,
     displayDecimals: 6,
+    priceProxySymbol: 'WBTC',
     priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
   },
   {
@@ -160,14 +168,12 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     displayDecimals: 6,
     priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
-  },
-  {
-    name: "xLBTC",
-    symbol: "xLBTC",
-    logo: "https://assets.strkfarm.com/integrations/tokens/xlbtc.svg",
-    address: ContractAddr.from(
-      "0x07dd3c80de9fcc5545f0cb83678826819c79619ed7992cc06ff81fc67cd2efe0"
-    ),
+    priceProxySymbol: 'WBTC',
+}, {
+    name: 'xLBTC',
+    symbol: 'xLBTC',
+    logo: 'https://assets.strkfarm.com/integrations/tokens/xlbtc.svg',
+    address: ContractAddr.from('0x07dd3c80de9fcc5545f0cb83678826819c79619ed7992cc06ff81fc67cd2efe0'),
     decimals: 8,
     coingeckId: undefined,
     displayDecimals: 6,
@@ -197,20 +203,54 @@ const defaultTokens: TokenInfo[] = [
     coingeckId: undefined,
     displayDecimals: 2,
     priceCheckAmount: 100,
-  },
-  {
-    name: "USDC",
-    symbol: "USDC",
-    logo: "https://assets.troves.fi/integrations/tokens/usdc.svg",
-    address: ContractAddr.from(
-      "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb"
-    ),
+}, {
+    name: "fyWBTC",
+    symbol: "fyWBTC",
+    logo: 'https://assets.strkfarm.com/integrations/tokens/wbtc.svg',
+    address: ContractAddr.from('0x04dd39de0a588f5e1c7a8377e1bef2c49caaee49a11433429d2c48f587b3a492'),
+    decimals: 8,
+    coingeckId: undefined,
+    displayDecimals: 6,
+    priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
+}, {
+    name: "fyETH",
+    symbol: "fyETH",
+    logo: 'https://assets.strkfarm.com/integrations/tokens/eth.svg',
+    address: ContractAddr.from('0x050707bC3b8730022F10530C2c6f6b9467644129C50C2868Ad0036c5e4E9e616'),
+    decimals: 18,
+    coingeckId: undefined,
+    displayDecimals: 4,
+    priceCheckAmount: 0.1,
+}, {
+    name: "fyUSDC",
+    symbol: "fyUSDC",
+    logo: 'https://assets.strkfarm.com/integrations/tokens/usdc.svg',
+    address: ContractAddr.from('0x07fdcec0cef01294c9c3d52415215949805c77bae8003702a7928fd6d2c36bc1'),
     decimals: 6,
     coingeckId: undefined,
     displayDecimals: 2,
     priceCheckAmount: 100,
-  },
-];
+}, {
+    name: 'strkBTC',
+    symbol: 'strkBTC',
+    logo: 'https://assets.troves.fi/integrations/tokens/strkbtc.svg',
+    address: ContractAddr.from('0x0787150e306e6eae6e3f79dea881770e8bbff2c1b8eb490f969669ee945b3135'),
+    decimals: 8,
+    coingeckId: undefined,
+    displayDecimals: 6,
+    priceCheckAmount: 0.001, // 112000 * 0.0001 = $110.2
+    priceProxySymbol: 'WBTC',
+}, {
+    name: 'xstrkBTC',
+    symbol: 'xstrkBTC',
+    logo: 'https://assets.troves.fi/integrations/tokens/xstrkbtc.svg',
+    address: ContractAddr.from('0x047751b3532fabca89b0f2e35ca1cb45e5a7b11d5e3d3663dfa1f4406b45fd88'),
+    decimals: 8,
+    coingeckId: undefined,
+    displayDecimals: 6,
+    priceCheckAmount: 0.001,
+    priceProxySymbol: 'WBTC',
+},]
 const tokens: TokenInfo[] = defaultTokens;
 
 /** Contains globally useful functions.
@@ -289,34 +329,49 @@ export class Global {
     }
   }
 
-  static async getTokenInfoFromAddr(addr: ContractAddr) {
+
+  static async getTokenInfoFromName(tokenName: string) {
     // if tokens are not loaded, load them
     if (tokens.length == defaultTokens.length) {
-      await Global.getTokens();
+        await Global.getTokens();
+    }
+
+    const token = tokens.find(
+        (token) => token.name.toLowerCase() === tokenName.toLowerCase()
+    );
+    if (!token) {
+        throw new FatalError(`Token not found: ${tokenName}`);
     }
+    return token;
+  }
 
+  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}`);
+        throw new FatalError(`Token not found: ${addr.address}`);
     }
     return token;
   }
 
   static setGlobalCache(key: string, data: any, ttl: number = 60000) {
-    Global.cache[key] = {
-      value: data,
-      ttl,
-      timestamp: Date.now(),
-    };
+      Global.cache[key] = {
+          value: data,
+          ttl,
+          timestamp: Date.now()
+      };
   }
 
   static getGlobalCache<T>(key: string): T | null {
-    const cached = Global.cache[key];
-    if (!cached) return null;
-    if (Date.now() - cached.timestamp > cached.ttl) {
-      delete Global.cache[key];
-      return null;
-    }
-    return cached.value;
+      const cached = Global.cache[key];
+      if (!cached) return null;
+      if (Date.now() - cached.timestamp > cached.ttl) {
+          delete Global.cache[key];
+          return null;
+      }
+      return cached.value;
   }
 }

package/src/index.browser.ts

@@ -3,4 +3,5 @@ export * from './modules';
 export * from './interfaces';
 export * from './dataTypes';
 export * from './global';
-export * from './strategies';
+export * from './strategies';
+export * from "./utils";