@strkfarm/sdk 2.0.0-dev.5 → 2.0.0-dev.50

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
+        });
+    }
+}