@defisaver/automation-sdk 3.2.2 → 3.2.3

package/esm/services/utils.d.ts

@@ -1,30 +1,30 @@
-import type { EthereumAddress } from '../types';
-import { ChainId, CloseStrategyType, CloseToAssetType, RatioState } from '../types/enums';
-export declare function isDefined<T>(value: T): value is NonNullable<T>;
-export declare function isUndefined(value: unknown): boolean;
-export declare function compareAddresses(firstAddress: EthereumAddress, secondAddress: EthereumAddress): boolean;
-export declare function isAddress(address: EthereumAddress): boolean;
-export declare function addToArrayIf(condition: boolean, ...items: any): Array<any>;
-export declare function addToObjectIf(condition: boolean, item: any): object;
-export declare function ethToWeth(maybeEth: string): string;
-export declare function wethToEth(maybeWeth: string): string;
-export declare function wethToEthByAddress(maybeWethAddr: EthereumAddress, chainId?: ChainId): EthereumAddress;
-export declare function compareSubHashes(currentSubHash: string, newSubStructDecoded: object): boolean;
-export declare function encodeSubId(subIdDec?: string): string;
-export declare function ratioPercentageToWei(ratioPercentage: number): string;
-export declare function weiToRatioPercentage(ratioWei: string): number;
-export declare function isRatioStateOver(ratioState: RatioState): boolean;
-export declare function isRatioStateUnder(ratioState: RatioState): boolean;
-export declare function isEmptyBytes(string: string): boolean;
-export declare function requireAddress(address: EthereumAddress): void | never;
-export declare function requireAddresses(addresses: EthereumAddress[]): void;
-export declare function getRatioStateInfoForAaveCloseStrategy(currentRatioState: RatioState, collAsset: EthereumAddress, debtAsset: EthereumAddress, chainId: ChainId): {
-    shouldFlip: boolean;
-    ratioState: RatioState;
-};
-export declare function getPositionId(...args: (number | string)[]): string;
-export declare function getCloseStrategyType(stopLossPrice: number, stopLossType: CloseToAssetType, takeProfitPrice: number, takeProfitType: CloseToAssetType): CloseStrategyType;
-export declare function getStopLossAndTakeProfitTypeByCloseStrategyType(closeStrategyType: CloseStrategyType): {
-    stopLossType: CloseToAssetType | undefined;
-    takeProfitType: CloseToAssetType | undefined;
-};
+import type { EthereumAddress } from '../types';
+import { ChainId, CloseStrategyType, CloseToAssetType, RatioState } from '../types/enums';
+export declare function isDefined<T>(value: T): value is NonNullable<T>;
+export declare function isUndefined(value: unknown): boolean;
+export declare function compareAddresses(firstAddress: EthereumAddress, secondAddress: EthereumAddress): boolean;
+export declare function isAddress(address: EthereumAddress): boolean;
+export declare function addToArrayIf(condition: boolean, ...items: any): Array<any>;
+export declare function addToObjectIf(condition: boolean, item: any): object;
+export declare function ethToWeth(maybeEth: string): string;
+export declare function wethToEth(maybeWeth: string): string;
+export declare function wethToEthByAddress(maybeWethAddr: EthereumAddress, chainId?: ChainId): EthereumAddress;
+export declare function compareSubHashes(currentSubHash: string, newSubStructDecoded: object): boolean;
+export declare function encodeSubId(subIdDec?: string): string;
+export declare function ratioPercentageToWei(ratioPercentage: number): string;
+export declare function weiToRatioPercentage(ratioWei: string): number;
+export declare function isRatioStateOver(ratioState: RatioState): boolean;
+export declare function isRatioStateUnder(ratioState: RatioState): boolean;
+export declare function isEmptyBytes(string: string): boolean;
+export declare function requireAddress(address: EthereumAddress): void | never;
+export declare function requireAddresses(addresses: EthereumAddress[]): void;
+export declare function getRatioStateInfoForAaveCloseStrategy(currentRatioState: RatioState, collAsset: EthereumAddress, debtAsset: EthereumAddress, chainId: ChainId): {
+    shouldFlip: boolean;
+    ratioState: RatioState;
+};
+export declare function getPositionId(...args: (number | string)[]): string;
+export declare function getCloseStrategyType(stopLossPrice: number, stopLossType: CloseToAssetType, takeProfitPrice: number, takeProfitType: CloseToAssetType): CloseStrategyType;
+export declare function getStopLossAndTakeProfitTypeByCloseStrategyType(closeStrategyType: CloseStrategyType): {
+    stopLossType: CloseToAssetType | undefined;
+    takeProfitType: CloseToAssetType | undefined;
+};

package/esm/services/utils.js

@@ -1,131 +1,131 @@
-import Dec from 'decimal.js';
-import * as web3Utils from 'web3-utils';
-import AbiCoder from 'web3-eth-abi';
-import { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
-import { ChainId, CloseStrategyType, CloseToAssetType, RatioState, } from '../types/enums';
-export function isDefined(value) {
-    return value !== undefined && value !== null;
-}
-export function isUndefined(value) {
-    return !isDefined(value);
-}
-export function compareAddresses(firstAddress, secondAddress) {
-    return firstAddress.toLowerCase() === secondAddress.toLowerCase();
-}
-export function isAddress(address) {
-    return new RegExp(/0x[0-9a-fA-F]{40}/).test(address);
-}
-export function addToArrayIf(condition, ...items) {
-    return (condition ? items : []);
-}
-export function addToObjectIf(condition, item) {
-    return (condition ? item : {});
-}
-export function ethToWeth(maybeEth) {
-    return maybeEth === null || maybeEth === void 0 ? void 0 : maybeEth.replace(/^ETH$/, 'WETH');
-}
-export function wethToEth(maybeWeth) {
-    return maybeWeth === null || maybeWeth === void 0 ? void 0 : maybeWeth.replace(/^WETH$/, 'ETH');
-}
-export function wethToEthByAddress(maybeWethAddr, chainId = ChainId.Ethereum) {
-    return getAssetInfo(wethToEth(getAssetInfoByAddress(maybeWethAddr, chainId).symbol), chainId).address;
-}
-export function compareSubHashes(currentSubHash, newSubStructDecoded) {
-    return currentSubHash === web3Utils.keccak256(AbiCoder.encodeParameter('(uint64,bool,bytes[],bytes32[])', newSubStructDecoded));
-}
-export function encodeSubId(subIdDec = '0') {
-    return new Dec(subIdDec).toHex().slice(2).padStart(8, '0');
-}
-export function ratioPercentageToWei(ratioPercentage) {
-    return web3Utils.toWei(new Dec(ratioPercentage).div(100).toString(), 'ether');
-}
-export function weiToRatioPercentage(ratioWei) {
-    return new Dec(web3Utils.fromWei(new Dec(ratioWei).mul(100).toString(), 'ether')).toNumber();
-}
-export function isRatioStateOver(ratioState) {
-    return ratioState === RatioState.OVER;
-}
-export function isRatioStateUnder(ratioState) {
-    return ratioState === RatioState.UNDER;
-}
-export function isEmptyBytes(string) {
-    return string === '0x0000000000000000000000000000000000000000';
-}
-export function requireAddress(address) {
-    if (typeof address !== 'string')
-        throw new Error('Address is not a string');
-    if (address === '')
-        throw new Error('Address is empty string');
-    if (address.length < 42)
-        throw new Error(`Address too short (${address.length} instead of 42)`);
-    if (isEmptyBytes(address))
-        throw new Error('Address is empty bytes');
-    if (!(new RegExp(/0x[0-9a-fA-F]{40}/).test(address)))
-        throw new Error('Address invalid');
-}
-export function requireAddresses(addresses) {
-    addresses.forEach((address) => requireAddress(address));
-}
-export function getRatioStateInfoForAaveCloseStrategy(currentRatioState, collAsset, debtAsset, chainId) {
-    // Flip only if stable/volatile to keep human-readable trigger price setting
-    const shouldFlip = getAssetInfoByAddress(collAsset, chainId).isStable && !getAssetInfoByAddress(debtAsset, chainId).isStable;
-    let ratioState = currentRatioState;
-    if (shouldFlip) {
-        ratioState = isRatioStateOver(currentRatioState)
-            ? ratioState = RatioState.UNDER
-            : ratioState = RatioState.OVER;
-    }
-    return { shouldFlip, ratioState };
-}
-export function getPositionId(...args) {
-    return args.map(arg => arg.toString().toLowerCase().split(' ').join('_')).join('-');
-}
-export function getCloseStrategyType(stopLossPrice, stopLossType, takeProfitPrice, takeProfitType) {
-    const isStopLoss = stopLossPrice > 0;
-    const isTakeProfit = takeProfitPrice > 0;
-    if (!isStopLoss && !isTakeProfit) {
-        throw new Error('CloseOnPrice: At least one price must be defined');
-    }
-    if (isStopLoss && isTakeProfit) {
-        if (stopLossType === CloseToAssetType.COLLATERAL && takeProfitType === CloseToAssetType.COLLATERAL) {
-            return CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_COLLATERAL;
-        }
-        if (stopLossType === CloseToAssetType.COLLATERAL) {
-            return CloseStrategyType.TAKE_PROFIT_IN_DEBT_AND_STOP_LOSS_IN_COLLATERAL;
-        }
-        if (takeProfitType === CloseToAssetType.COLLATERAL) {
-            return CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL_AND_STOP_LOSS_IN_DEBT;
-        }
-        return CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_DEBT;
-    }
-    if (isStopLoss) {
-        return stopLossType === CloseToAssetType.COLLATERAL
-            ? CloseStrategyType.STOP_LOSS_IN_COLLATERAL
-            : CloseStrategyType.STOP_LOSS_IN_DEBT;
-    }
-    return takeProfitType === CloseToAssetType.COLLATERAL
-        ? CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL
-        : CloseStrategyType.TAKE_PROFIT_IN_DEBT;
-}
-export function getStopLossAndTakeProfitTypeByCloseStrategyType(closeStrategyType) {
-    switch (closeStrategyType) {
-        case CloseStrategyType.STOP_LOSS_IN_COLLATERAL:
-            return { stopLossType: CloseToAssetType.COLLATERAL, takeProfitType: undefined };
-        case CloseStrategyType.STOP_LOSS_IN_DEBT:
-            return { stopLossType: CloseToAssetType.DEBT, takeProfitType: undefined };
-        case CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL:
-            return { stopLossType: undefined, takeProfitType: CloseToAssetType.COLLATERAL };
-        case CloseStrategyType.TAKE_PROFIT_IN_DEBT:
-            return { stopLossType: undefined, takeProfitType: CloseToAssetType.DEBT };
-        case CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL_AND_STOP_LOSS_IN_DEBT:
-            return { stopLossType: CloseToAssetType.DEBT, takeProfitType: CloseToAssetType.COLLATERAL };
-        case CloseStrategyType.TAKE_PROFIT_IN_DEBT_AND_STOP_LOSS_IN_COLLATERAL:
-            return { stopLossType: CloseToAssetType.COLLATERAL, takeProfitType: CloseToAssetType.DEBT };
-        case CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_DEBT:
-            return { stopLossType: CloseToAssetType.DEBT, takeProfitType: CloseToAssetType.DEBT };
-        case CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_COLLATERAL:
-            return { stopLossType: CloseToAssetType.COLLATERAL, takeProfitType: CloseToAssetType.COLLATERAL };
-        default:
-            throw new Error('CloseStrategyType not supported');
-    }
-}
+import Dec from 'decimal.js';
+import * as web3Utils from 'web3-utils';
+import AbiCoder from 'web3-eth-abi';
+import { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import { ChainId, CloseStrategyType, CloseToAssetType, RatioState, } from '../types/enums';
+export function isDefined(value) {
+    return value !== undefined && value !== null;
+}
+export function isUndefined(value) {
+    return !isDefined(value);
+}
+export function compareAddresses(firstAddress, secondAddress) {
+    return firstAddress.toLowerCase() === secondAddress.toLowerCase();
+}
+export function isAddress(address) {
+    return new RegExp(/0x[0-9a-fA-F]{40}/).test(address);
+}
+export function addToArrayIf(condition, ...items) {
+    return (condition ? items : []);
+}
+export function addToObjectIf(condition, item) {
+    return (condition ? item : {});
+}
+export function ethToWeth(maybeEth) {
+    return maybeEth === null || maybeEth === void 0 ? void 0 : maybeEth.replace(/^ETH$/, 'WETH');
+}
+export function wethToEth(maybeWeth) {
+    return maybeWeth === null || maybeWeth === void 0 ? void 0 : maybeWeth.replace(/^WETH$/, 'ETH');
+}
+export function wethToEthByAddress(maybeWethAddr, chainId = ChainId.Ethereum) {
+    return getAssetInfo(wethToEth(getAssetInfoByAddress(maybeWethAddr, chainId).symbol), chainId).address;
+}
+export function compareSubHashes(currentSubHash, newSubStructDecoded) {
+    return currentSubHash === web3Utils.keccak256(AbiCoder.encodeParameter('(uint64,bool,bytes[],bytes32[])', newSubStructDecoded));
+}
+export function encodeSubId(subIdDec = '0') {
+    return new Dec(subIdDec).toHex().slice(2).padStart(8, '0');
+}
+export function ratioPercentageToWei(ratioPercentage) {
+    return web3Utils.toWei(new Dec(ratioPercentage).div(100).toString(), 'ether');
+}
+export function weiToRatioPercentage(ratioWei) {
+    return new Dec(web3Utils.fromWei(new Dec(ratioWei).mul(100).toString(), 'ether')).toNumber();
+}
+export function isRatioStateOver(ratioState) {
+    return ratioState === RatioState.OVER;
+}
+export function isRatioStateUnder(ratioState) {
+    return ratioState === RatioState.UNDER;
+}
+export function isEmptyBytes(string) {
+    return string === '0x0000000000000000000000000000000000000000';
+}
+export function requireAddress(address) {
+    if (typeof address !== 'string')
+        throw new Error('Address is not a string');
+    if (address === '')
+        throw new Error('Address is empty string');
+    if (address.length < 42)
+        throw new Error(`Address too short (${address.length} instead of 42)`);
+    if (isEmptyBytes(address))
+        throw new Error('Address is empty bytes');
+    if (!(new RegExp(/0x[0-9a-fA-F]{40}/).test(address)))
+        throw new Error('Address invalid');
+}
+export function requireAddresses(addresses) {
+    addresses.forEach((address) => requireAddress(address));
+}
+export function getRatioStateInfoForAaveCloseStrategy(currentRatioState, collAsset, debtAsset, chainId) {
+    // Flip only if stable/volatile to keep human-readable trigger price setting
+    const shouldFlip = getAssetInfoByAddress(collAsset, chainId).isStable && !getAssetInfoByAddress(debtAsset, chainId).isStable;
+    let ratioState = currentRatioState;
+    if (shouldFlip) {
+        ratioState = isRatioStateOver(currentRatioState)
+            ? ratioState = RatioState.UNDER
+            : ratioState = RatioState.OVER;
+    }
+    return { shouldFlip, ratioState };
+}
+export function getPositionId(...args) {
+    return args.map(arg => arg.toString().toLowerCase().split(' ').join('_')).join('-');
+}
+export function getCloseStrategyType(stopLossPrice, stopLossType, takeProfitPrice, takeProfitType) {
+    const isStopLoss = stopLossPrice > 0;
+    const isTakeProfit = takeProfitPrice > 0;
+    if (!isStopLoss && !isTakeProfit) {
+        throw new Error('CloseOnPrice: At least one price must be defined');
+    }
+    if (isStopLoss && isTakeProfit) {
+        if (stopLossType === CloseToAssetType.COLLATERAL && takeProfitType === CloseToAssetType.COLLATERAL) {
+            return CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_COLLATERAL;
+        }
+        if (stopLossType === CloseToAssetType.COLLATERAL) {
+            return CloseStrategyType.TAKE_PROFIT_IN_DEBT_AND_STOP_LOSS_IN_COLLATERAL;
+        }
+        if (takeProfitType === CloseToAssetType.COLLATERAL) {
+            return CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL_AND_STOP_LOSS_IN_DEBT;
+        }
+        return CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_DEBT;
+    }
+    if (isStopLoss) {
+        return stopLossType === CloseToAssetType.COLLATERAL
+            ? CloseStrategyType.STOP_LOSS_IN_COLLATERAL
+            : CloseStrategyType.STOP_LOSS_IN_DEBT;
+    }
+    return takeProfitType === CloseToAssetType.COLLATERAL
+        ? CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL
+        : CloseStrategyType.TAKE_PROFIT_IN_DEBT;
+}
+export function getStopLossAndTakeProfitTypeByCloseStrategyType(closeStrategyType) {
+    switch (closeStrategyType) {
+        case CloseStrategyType.STOP_LOSS_IN_COLLATERAL:
+            return { stopLossType: CloseToAssetType.COLLATERAL, takeProfitType: undefined };
+        case CloseStrategyType.STOP_LOSS_IN_DEBT:
+            return { stopLossType: CloseToAssetType.DEBT, takeProfitType: undefined };
+        case CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL:
+            return { stopLossType: undefined, takeProfitType: CloseToAssetType.COLLATERAL };
+        case CloseStrategyType.TAKE_PROFIT_IN_DEBT:
+            return { stopLossType: undefined, takeProfitType: CloseToAssetType.DEBT };
+        case CloseStrategyType.TAKE_PROFIT_IN_COLLATERAL_AND_STOP_LOSS_IN_DEBT:
+            return { stopLossType: CloseToAssetType.DEBT, takeProfitType: CloseToAssetType.COLLATERAL };
+        case CloseStrategyType.TAKE_PROFIT_IN_DEBT_AND_STOP_LOSS_IN_COLLATERAL:
+            return { stopLossType: CloseToAssetType.COLLATERAL, takeProfitType: CloseToAssetType.DEBT };
+        case CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_DEBT:
+            return { stopLossType: CloseToAssetType.DEBT, takeProfitType: CloseToAssetType.DEBT };
+        case CloseStrategyType.TAKE_PROFIT_AND_STOP_LOSS_IN_COLLATERAL:
+            return { stopLossType: CloseToAssetType.COLLATERAL, takeProfitType: CloseToAssetType.COLLATERAL };
+        default:
+            throw new Error('CloseStrategyType not supported');
+    }
+}

package/esm/services/utils.test.d.ts

@@ -1 +1 @@
-import '../configuration';
+import '../configuration';