@defisaver/automation-sdk 1.0.1

package/esm/constants/index.js

@@ -0,0 +1,153 @@
+import { ChainId, ProtocolIdentifiers, Strategies, Bundles, BundleProtocols, } from '../types/enums';
+import Protocol from '../automation/private/Protocol';
+import LegacyProtocol from '../automation/private/LegacyProtocol';
+// General
+export const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+export const PROTOCOLS = (() => {
+    const protocolsMapping = {};
+    Object.entries(ProtocolIdentifiers.StrategiesAutomation).forEach(([id, value]) => {
+        protocolsMapping[id] = new Protocol({ id: value });
+    });
+    return protocolsMapping;
+})();
+export const LEGACY_PROTOCOLS = (() => {
+    const protocolsMapping = {};
+    Object.entries(ProtocolIdentifiers.LegacyAutomation).forEach(([id, value]) => {
+        protocolsMapping[id] = new LegacyProtocol({ id: value });
+    });
+    return protocolsMapping;
+})();
+// Strategies info
+export const MAINNET_STRATEGIES_INFO = {
+    [Strategies.MainnetIds.MAKER_CLOSE_ON_PRICE_TO_DAI]: {
+        strategyId: Strategies.Identifiers.CloseOnPriceToDebt,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Strategies.MainnetIds.MAKER_CLOSE_ON_PRICE_TO_COLL]: {
+        strategyId: Strategies.Identifiers.CloseOnPriceToColl,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Strategies.MainnetIds.LIQUITY_CLOSE_ON_PRICE_TO_COLL_DEPRECATED]: {
+        strategyId: Strategies.Identifiers.CloseOnPriceToColl,
+        protocol: PROTOCOLS.Liquity,
+    },
+    [Strategies.MainnetIds.LIQUITY_CLOSE_ON_PRICE_TO_COLL]: {
+        strategyId: Strategies.Identifiers.CloseOnPriceToColl,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Strategies.MainnetIds.MAKER_TRAILING_STOP_LOSS_TO_COLL]: {
+        strategyId: Strategies.Identifiers.TrailingStopToColl,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Strategies.MainnetIds.MAKER_TRAILING_STOP_LOSS_TO_DAI]: {
+        strategyId: Strategies.Identifiers.TrailingStopToDebt,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Strategies.MainnetIds.LIQUITY_TRAILING_STOP_LOSS_TO_COLL]: {
+        strategyId: Strategies.Identifiers.TrailingStopToColl,
+        protocol: PROTOCOLS.Liquity,
+    },
+    [Strategies.MainnetIds.CHICKEN_BONDS_REBOND]: {
+        strategyId: Strategies.Identifiers.Rebond,
+        protocol: PROTOCOLS.ChickenBonds,
+    },
+};
+export const OPTIMISM_STRATEGIES_INFO = {};
+export const ARBITRUM_STRATEGIES_INFO = {};
+export const STRATEGIES_INFO = {
+    [ChainId.Ethereum]: MAINNET_STRATEGIES_INFO,
+    [ChainId.Optimism]: OPTIMISM_STRATEGIES_INFO,
+    [ChainId.Arbitrum]: ARBITRUM_STRATEGIES_INFO,
+};
+export const STRATEGY_IDS = {
+    [ChainId.Ethereum]: Strategies.MainnetIds,
+    [ChainId.Optimism]: Strategies.OptimismIds,
+    [ChainId.Arbitrum]: Strategies.ArbitrumIds,
+};
+// Bundles info
+export const MAINNET_BUNDLES_INFO = {
+    [Bundles.MainnetIds.MAKER_REPAY_FROM_SMART_SAVINGS_YEARN]: {
+        bundleId: BundleProtocols.Yearn,
+        bundleName: 'Yearn',
+        strategyId: Strategies.Identifiers.SavingsLiqProtection,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Bundles.MainnetIds.MAKER_REPAY_FROM_SMART_SAVINGS_MSTABLE]: {
+        bundleId: BundleProtocols.MStable,
+        bundleName: 'mStable',
+        strategyId: Strategies.Identifiers.SavingsLiqProtection,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Bundles.MainnetIds.MAKER_REPAY_FROM_SMART_SAVINGS_RARI]: {
+        bundleId: BundleProtocols.Rari,
+        bundleName: 'Rari',
+        strategyId: Strategies.Identifiers.SavingsLiqProtection,
+        protocol: PROTOCOLS.MakerDAO,
+    },
+    [Bundles.MainnetIds.COMP_V3_SW_REPAY_BUNDLE]: {
+        strategyId: Strategies.Identifiers.Repay,
+        protocol: PROTOCOLS.CompoundV3,
+    },
+    [Bundles.MainnetIds.COMP_V3_SW_BOOST_BUNDLE]: {
+        strategyId: Strategies.Identifiers.Boost,
+        protocol: PROTOCOLS.CompoundV3,
+    },
+    [Bundles.MainnetIds.COMP_V3_EOA_REPAY_BUNDLE]: {
+        strategyId: Strategies.Identifiers.EoaRepay,
+        protocol: PROTOCOLS.CompoundV3,
+    },
+    [Bundles.MainnetIds.COMP_V3_EOA_BOOST_BUNDLE]: {
+        strategyId: Strategies.Identifiers.EoaBoost,
+        protocol: PROTOCOLS.CompoundV3,
+    },
+    [Bundles.MainnetIds.LIQUITY_PAYBACK_USING_CHICKEN_BOND]: {
+        strategyId: Strategies.Identifiers.BondProtection,
+        protocol: PROTOCOLS.Liquity,
+    },
+};
+export const OPTIMISM_BUNDLES_INFO = {
+    [Bundles.OptimismIds.AAVE_V3_REPAY]: {
+        strategyId: Strategies.Identifiers.Repay,
+        protocol: PROTOCOLS.AaveV3,
+    },
+    [Bundles.OptimismIds.AAVE_V3_BOOST]: {
+        strategyId: Strategies.Identifiers.Boost,
+        protocol: PROTOCOLS.AaveV3,
+    },
+    [Bundles.OptimismIds.AAVE_V3_CLOSE_TO_DEBT]: {
+        strategyId: Strategies.Identifiers.CloseToDebt,
+        protocol: PROTOCOLS.AaveV3,
+    },
+    [Bundles.OptimismIds.AAVE_V3_CLOSE_TO_COLLATERAL]: {
+        strategyId: Strategies.Identifiers.CloseToCollateral,
+        protocol: PROTOCOLS.AaveV3,
+    },
+};
+export const ARBITRUM_BUNDLES_INFO = {
+    [Bundles.ArbitrumIds.AAVE_V3_REPAY]: {
+        strategyId: Strategies.Identifiers.Repay,
+        protocol: PROTOCOLS.AaveV3,
+    },
+    [Bundles.ArbitrumIds.AAVE_V3_BOOST]: {
+        strategyId: Strategies.Identifiers.Boost,
+        protocol: PROTOCOLS.AaveV3,
+    },
+    [Bundles.ArbitrumIds.AAVE_V3_CLOSE_TO_DEBT]: {
+        strategyId: Strategies.Identifiers.CloseToDebt,
+        protocol: PROTOCOLS.AaveV3,
+    },
+    [Bundles.ArbitrumIds.AAVE_V3_CLOSE_TO_COLLATERAL]: {
+        strategyId: Strategies.Identifiers.CloseToCollateral,
+        protocol: PROTOCOLS.AaveV3,
+    },
+};
+export const BUNDLES_INFO = {
+    [ChainId.Ethereum]: MAINNET_BUNDLES_INFO,
+    [ChainId.Optimism]: OPTIMISM_BUNDLES_INFO,
+    [ChainId.Arbitrum]: ARBITRUM_BUNDLES_INFO,
+};
+export const BUNDLE_IDS = {
+    [ChainId.Ethereum]: Bundles.MainnetIds,
+    [ChainId.Optimism]: Bundles.OptimismIds,
+    [ChainId.Arbitrum]: Bundles.ArbitrumIds,
+};

package/esm/index.d.ts

@@ -0,0 +1,20 @@
+import './configuration';
+import LegacyMakerAutomation from './automation/public/legacy/LegacyMakerAutomation';
+import LegacyAaveAutomation from './automation/public/legacy/LegacyAaveAutomation';
+import LegacyCompoundAutomation from './automation/public/legacy/LegacyCompoundAutomation';
+import EthereumStrategies from './automation/public/EthereumStrategies';
+import OptimismStrategies from './automation/public/OptimismStrategies';
+import ArbitrumStrategies from './automation/public/ArbitrumStrategies';
+import * as triggerService from './services/triggerService';
+import * as subDataService from './services/subDataService';
+import * as strategySubService from './services/strategySubService';
+import * as constants from './constants';
+import { getRatioStateInfoForAaveCloseStrategy, compareSubHashes } from './services/utils';
+import * as enums from './types/enums';
+import type * as types from './types';
+declare const utils: {
+    getRatioStateInfoForAaveCloseStrategy: typeof getRatioStateInfoForAaveCloseStrategy;
+    compareSubHashes: typeof compareSubHashes;
+};
+export { LegacyMakerAutomation, LegacyAaveAutomation, LegacyCompoundAutomation, EthereumStrategies, OptimismStrategies, ArbitrumStrategies, triggerService, subDataService, strategySubService, utils, enums, constants, };
+export type { types };

package/esm/index.js

@@ -0,0 +1,22 @@
+// TODO
+//  [] Check @ts-ignores and PlaceholderType
+//  [] Improve typing for subData, trigger and strategySub services
+//  [] Make possible to use any provider not only web3 (This requires changes throughout the package)
+//  [] Write unit tests
+import './configuration';
+import LegacyMakerAutomation from './automation/public/legacy/LegacyMakerAutomation';
+import LegacyAaveAutomation from './automation/public/legacy/LegacyAaveAutomation';
+import LegacyCompoundAutomation from './automation/public/legacy/LegacyCompoundAutomation';
+import EthereumStrategies from './automation/public/EthereumStrategies';
+import OptimismStrategies from './automation/public/OptimismStrategies';
+import ArbitrumStrategies from './automation/public/ArbitrumStrategies';
+import * as triggerService from './services/triggerService';
+import * as subDataService from './services/subDataService';
+import * as strategySubService from './services/strategySubService';
+import * as constants from './constants';
+import { getRatioStateInfoForAaveCloseStrategy, compareSubHashes } from './services/utils';
+import * as enums from './types/enums';
+const utils = {
+    getRatioStateInfoForAaveCloseStrategy, compareSubHashes,
+};
+export { LegacyMakerAutomation, LegacyAaveAutomation, LegacyCompoundAutomation, EthereumStrategies, OptimismStrategies, ArbitrumStrategies, triggerService, subDataService, strategySubService, utils, enums, constants, };

package/esm/services/contractService.d.ts

@@ -0,0 +1,11 @@
+import type Web3 from 'web3';
+import type { AbiItem } from 'web3-utils';
+import type { Contract } from '../types';
+import type { BaseContract } from '../types/contracts/generated/types';
+import type { Legacy_AuthCheck, SubStorage, UniMulticall } from '../types/contracts/generated';
+import { ChainId } from '../types/enums';
+export declare function getAbiItem(abi: AbiItem[], itemName: string): AbiItem;
+export declare function makeUniMulticallContract(web3: Web3, chainId: ChainId): Contract.WithMeta<UniMulticall>;
+export declare function makeSubStorageContract(web3: Web3, chainId: ChainId): Contract.WithMeta<SubStorage>;
+export declare function makeAuthCheckerContract(web3: Web3, chainId: ChainId): Contract.WithMeta<Legacy_AuthCheck>;
+export declare function makeLegacySubscriptionContract<T extends BaseContract>(web3: Web3, contractJson: Contract.Json): Contract.WithMeta<T>;

package/esm/services/contractService.js

@@ -0,0 +1,40 @@
+import { UniMulticallJson, SubStorageJson, AuthCheckJson } from '../abis';
+import { isDefined } from './utils';
+import { ChainId } from '../types/enums';
+export function getAbiItem(abi, itemName) {
+    const abiItem = abi.find(i => i.name === itemName);
+    if (isDefined(abiItem)) {
+        return abiItem;
+    }
+    throw new Error(`Can't find abi item for itemName: ${itemName}`);
+}
+function makeContract(web3, contractJson, chainId) {
+    const { abi } = contractJson;
+    let _address = '';
+    let _createdBlock = 'earliest';
+    if (contractJson.networks) {
+        const { address, createdBlock } = contractJson.networks[chainId];
+        _address = address;
+        if (isDefined(createdBlock)) {
+            _createdBlock = createdBlock;
+        }
+    }
+    return {
+        abi,
+        address: _address,
+        createdBlock: _createdBlock,
+        contract: new web3.eth.Contract(abi, _address),
+    };
+}
+export function makeUniMulticallContract(web3, chainId) {
+    return makeContract(web3, UniMulticallJson, chainId);
+}
+export function makeSubStorageContract(web3, chainId) {
+    return makeContract(web3, SubStorageJson, chainId);
+}
+export function makeAuthCheckerContract(web3, chainId) {
+    return makeContract(web3, AuthCheckJson, chainId);
+}
+export function makeLegacySubscriptionContract(web3, contractJson) {
+    return makeContract(web3, contractJson, ChainId.Ethereum);
+}

package/esm/services/ethereumService.d.ts

@@ -0,0 +1,7 @@
+import type Web3 from 'web3';
+import type { PastEventOptions } from 'web3-eth-contract';
+import type { BlockNumber, Multicall, Contract } from '../types';
+import type { BaseContract } from '../types/contracts/generated/types';
+import type { ChainId } from '../types/enums';
+export declare function multicall(web3: Web3, chainId: ChainId, calls: Multicall.Calls[], block?: BlockNumber): Promise<Multicall.Payload>;
+export declare function getEventsFromContract<T extends BaseContract>(contractWithMeta: Contract.WithMeta<T>, event: string, options?: PastEventOptions): Promise<import("web3-eth-contract").EventData[]>;

package/esm/services/ethereumService.js

@@ -0,0 +1,34 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { makeUniMulticallContract } from './contractService';
+import { addToObjectIf, isDefined } from './utils';
+const { mockedWeb3 } = process;
+export function multicall(web3, chainId, calls, block = 'latest') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const multicallContract = makeUniMulticallContract(web3, chainId).contract;
+        const formattedCalls = calls.map((call) => ({
+            callData: mockedWeb3.eth.abi.encodeFunctionCall(call.abiItem, call.params),
+            target: call.target || '0x0',
+            gasLimit: call.gasLimit || 1e6,
+        }));
+        const callResult = yield multicallContract.methods.multicall(formattedCalls.filter(item => item.target !== '0x0')).call({}, block);
+        let formattedResult = [];
+        callResult.returnData.forEach(([success, gasUsed, result], i) => {
+            const formattedRes = (result !== '0x'
+                ? mockedWeb3.eth.abi.decodeParameters(calls[i].abiItem.outputs, result)
+                : undefined);
+            formattedResult = [...formattedResult, formattedRes];
+        });
+        return formattedResult;
+    });
+}
+export function getEventsFromContract(contractWithMeta, event, options) {
+    return contractWithMeta.contract.getPastEvents(event, Object.assign(Object.assign({}, addToObjectIf(isDefined(options), options)), { fromBlock: contractWithMeta.createdBlock }));
+}

package/esm/services/strategiesService.d.ts

@@ -0,0 +1,2 @@
+import type { Position, ParseData } from '../types';
+export declare function parseStrategiesAutomatedPosition(parseData: ParseData): Position.Automated | null;

package/esm/services/strategiesService.js

@@ -0,0 +1,244 @@
+import { cloneDeep } from 'lodash';
+import { BUNDLES_INFO, STRATEGIES_INFO } from '../constants';
+import { ProtocolIdentifiers, Strategies } from '../types/enums';
+import { getRatioStateInfoForAaveCloseStrategy, isRatioStateOver, wethToEthByAddress } from './utils';
+import * as subDataService from './subDataService';
+import * as triggerService from './triggerService';
+function parseMakerSavingsLiqProtection(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.makerRatioTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.makerRepayFromSavingsSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.specific = {
+        minRatio: Number(triggerData.ratio),
+        minOptimalRatio: Number(subData.targetRatio),
+        repayEnabled: true,
+        boostEnabled: false,
+    };
+    return _position;
+}
+function parseMakerCloseOnPrice(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.chainlinkPriceTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.makerCloseSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    const isTakeProfit = isRatioStateOver(Number(triggerData.state));
+    _position.strategy.strategyId = isTakeProfit ? Strategies.IdOverrides.TakeProfit : Strategies.IdOverrides.StopLoss;
+    _position.specific = {
+        price: triggerData.price,
+        closeToAssetAddr: subData.closeToAssetAddr,
+    };
+    return _position;
+}
+function parseMakerTrailingStop(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.trailingStopTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.makerCloseSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.strategy.strategyId = Strategies.IdOverrides.TrailingStop;
+    _position.specific = {
+        triggerPercentage: Number(triggerData.triggerPercentage),
+        roundId: Number(triggerData.roundId),
+        closeToAssetAddr: subData.closeToAssetAddr,
+    };
+    return _position;
+}
+function parseLiquityCloseOnPrice(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.chainlinkPriceTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.liquityCloseSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    const isTakeProfit = isRatioStateOver(Number(triggerData.state));
+    _position.strategy.strategyId = isTakeProfit ? Strategies.IdOverrides.TakeProfit : Strategies.IdOverrides.StopLoss;
+    _position.specific = {
+        price: triggerData.price,
+        closeToAssetAddr: subData.closeToAssetAddr,
+    };
+    return _position;
+}
+function parseLiquityTrailingStop(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.trailingStopTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.liquityCloseSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.strategy.strategyId = Strategies.IdOverrides.TrailingStop;
+    _position.specific = {
+        triggerPercentage: Number(triggerData.triggerPercentage),
+        roundId: Number(triggerData.roundId),
+        closeToAssetAddr: subData.closeToAssetAddr,
+    };
+    return _position;
+}
+function parseAaveV3LeverageManagement(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct, subId } = parseData.subscriptionEventData;
+    const { isEnabled } = parseData.strategiesSubsData;
+    const triggerData = triggerService.aaveV3RatioTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.aaveLeverageManagementSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    const isRepay = _position.strategy.strategyId === Strategies.Identifiers.Repay;
+    if (isRepay) {
+        _position.specific = {
+            minRatio: triggerData.ratio,
+            minOptimalRatio: subData.targetRatio,
+            repayEnabled: true,
+            subId1: Number(subId),
+        };
+    }
+    else {
+        _position.specific = {
+            maxRatio: triggerData.ratio,
+            maxOptimalRatio: subData.targetRatio,
+            boostEnabled: isEnabled,
+            subId2: Number(subId),
+        };
+    }
+    _position.strategy.strategyId = Strategies.IdOverrides.LeverageManagement;
+    _position.specific.mergeWithSameId = true;
+    return _position;
+}
+function parseAaveV3CloseOnPrice(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.aaveV3QuotePriceTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.aaveV3QuotePriceSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    _position.specific = {
+        collAsset: subData.collAsset,
+        collAssetId: subData.collAssetId,
+        debtAsset: subData.debtAsset,
+        debtAssetId: subData.debtAssetId,
+        baseToken: triggerData.baseTokenAddress,
+        quoteToken: triggerData.quoteTokenAddress,
+        price: triggerData.price,
+        ratioState: triggerData.ratioState,
+    };
+    const { ratioState } = getRatioStateInfoForAaveCloseStrategy(_position.specific.ratioState, wethToEthByAddress(_position.specific.collAsset), wethToEthByAddress(_position.specific.debtAsset), parseData.chainId);
+    _position.strategy.strategyId = isRatioStateOver(ratioState) ? Strategies.IdOverrides.TakeProfit : Strategies.IdOverrides.StopLoss;
+    return _position;
+}
+function parseCompoundV3LeverageManagement(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct, subId } = parseData.subscriptionEventData;
+    const { isEnabled } = parseData.strategiesSubsData;
+    const triggerData = triggerService.compoundV3RatioTrigger.decode(subStruct.triggerData);
+    const subData = subDataService.compoundV3LeverageManagementSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.strategyData.decoded.subData = subData;
+    const isRepay = [Strategies.Identifiers.Repay, Strategies.Identifiers.EoaRepay].includes(_position.strategy.strategyId);
+    if (isRepay) {
+        _position.specific = {
+            minRatio: triggerData.ratio,
+            minOptimalRatio: subData.targetRatio,
+            repayEnabled: true,
+            subId1: Number(subId),
+        };
+    }
+    else {
+        _position.specific = {
+            maxRatio: triggerData.ratio,
+            maxOptimalRatio: subData.targetRatio,
+            boostEnabled: isEnabled,
+            subId2: Number(subId),
+        };
+    }
+    const isEOA = _position.strategy.strategyId.includes('eoa');
+    _position.strategy.strategyId = isEOA ? Strategies.IdOverrides.EoaLeverageManagement : Strategies.IdOverrides.LeverageManagement;
+    _position.specific.mergeWithSameId = true;
+    return _position;
+}
+function parseChickenBondsRebond(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    _position.strategyData.decoded.triggerData = triggerService.cBondsRebondTrigger.decode(subStruct.triggerData);
+    _position.strategyData.decoded.subData = subDataService.cBondsRebondSubData.decode(subStruct.subData);
+    return _position;
+}
+function parseLiquityBondProtection(position, parseData) {
+    const _position = cloneDeep(position);
+    const { subStruct } = parseData.subscriptionEventData;
+    const triggerData = triggerService.liquityRatioTrigger.decode(subStruct.triggerData);
+    _position.strategyData.decoded.subData = subDataService.liquityPaybackUsingChickenBondSubData.decode(subStruct.subData);
+    _position.strategyData.decoded.triggerData = triggerData;
+    _position.specific = {
+        minRatio: Number(triggerData.ratio),
+        minOptimalRatio: Infinity,
+        repayEnabled: true,
+    };
+    return _position;
+}
+const parsingMethodsMapping = {
+    [ProtocolIdentifiers.StrategiesAutomation.MakerDAO]: {
+        [Strategies.Identifiers.SavingsLiqProtection]: parseMakerSavingsLiqProtection,
+        [Strategies.Identifiers.CloseOnPriceToDebt]: parseMakerCloseOnPrice,
+        [Strategies.Identifiers.CloseOnPriceToColl]: parseMakerCloseOnPrice,
+        [Strategies.Identifiers.TrailingStopToColl]: parseMakerTrailingStop,
+        [Strategies.Identifiers.TrailingStopToDebt]: parseMakerTrailingStop,
+    },
+    [ProtocolIdentifiers.StrategiesAutomation.Liquity]: {
+        [Strategies.Identifiers.CloseOnPriceToColl]: parseLiquityCloseOnPrice,
+        [Strategies.Identifiers.TrailingStopToColl]: parseLiquityTrailingStop,
+        [Strategies.Identifiers.BondProtection]: parseLiquityBondProtection,
+    },
+    [ProtocolIdentifiers.StrategiesAutomation.AaveV3]: {
+        [Strategies.Identifiers.Repay]: parseAaveV3LeverageManagement,
+        [Strategies.Identifiers.Boost]: parseAaveV3LeverageManagement,
+        [Strategies.Identifiers.CloseToDebt]: parseAaveV3CloseOnPrice,
+        [Strategies.Identifiers.CloseToCollateral]: parseAaveV3CloseOnPrice,
+    },
+    [ProtocolIdentifiers.StrategiesAutomation.CompoundV3]: {
+        [Strategies.Identifiers.Repay]: parseCompoundV3LeverageManagement,
+        [Strategies.Identifiers.Boost]: parseCompoundV3LeverageManagement,
+        [Strategies.Identifiers.EoaRepay]: parseCompoundV3LeverageManagement,
+        [Strategies.Identifiers.EoaBoost]: parseCompoundV3LeverageManagement,
+    },
+    [ProtocolIdentifiers.StrategiesAutomation.ChickenBonds]: {
+        [Strategies.Identifiers.Rebond]: parseChickenBondsRebond,
+    },
+};
+function getParsingMethod(id, strategy) {
+    return parsingMethodsMapping[id][strategy.strategyId];
+}
+export function parseStrategiesAutomatedPosition(parseData) {
+    const { chainId, subscriptionEventData, strategiesSubsData } = parseData;
+    const { subStruct, proxy, subId } = subscriptionEventData;
+    const { isEnabled } = strategiesSubsData;
+    const id = subStruct.strategyOrBundleId;
+    const strategyOrBundleInfo = (subStruct.isBundle
+        ? BUNDLES_INFO[chainId][id]
+        : STRATEGIES_INFO[chainId][id]);
+    if (!strategyOrBundleInfo)
+        return null;
+    const position = {
+        isEnabled,
+        chainId,
+        subId: Number(subId),
+        owner: proxy,
+        protocol: Object.assign({}, strategyOrBundleInfo.protocol),
+        strategy: Object.assign({ isBundle: subStruct.isBundle }, strategyOrBundleInfo),
+        strategyData: {
+            encoded: {
+                triggerData: subStruct.triggerData,
+                subData: subStruct.subData,
+            },
+            decoded: {
+                triggerData: null,
+                subData: null,
+            },
+        },
+        specific: {},
+    };
+    return getParsingMethod(position.protocol.id, position.strategy)(position, parseData);
+}

package/esm/services/strategySubService.d.ts

@@ -0,0 +1,32 @@
+import { Bundles, ChainId, RatioState, Strategies } from '../types/enums';
+import type { EthereumAddress, StrategyOrBundleIds } from '../types';
+export declare const makerEncode: {
+    repayFromSavings(bundleId: StrategyOrBundleIds, vaultId: number, priceOverOrUnder: RatioState, targetRatio: number, chainId?: ChainId, isBundle?: boolean, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[])[];
+    closeOnPrice(vaultId: number, ratioState: RatioState, price: string, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
+    trailingStop(vaultId: number, triggerPercentage: number, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, roundId: number, chainId?: ChainId, daiAddr?: EthereumAddress, mcdCdpManagerAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
+};
+export declare const liquityEncode: {
+    closeOnPrice(priceOverOrUnder: RatioState, price: string, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, chainId?: ChainId, collAddr?: EthereumAddress, debtAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
+    trailingStop(triggerPercentage: number, closeToAssetAddr: EthereumAddress, chainlinkCollAddress: EthereumAddress, roundId: number, chainId?: ChainId, collAddr?: EthereumAddress, debtAddr?: EthereumAddress): (boolean | string[] | Strategies.MainnetIds)[];
+    paybackFromChickenBondStrategySub(proxyAddress: EthereumAddress, ratio: number, sourceId: string, sourceType: number, ratioState?: RatioState): (boolean | string[] | Bundles.MainnetIds)[];
+};
+export declare const chickenBondsEncode: {
+    rebond(bondId: number): string[];
+};
+export declare const aaveV3Encode: {
+    leverageManagement(minRatio: number, maxRatio: number, maxOptimalRatio: number, minOptimalRatio: number, boostEnabled: boolean): string;
+    closeToAsset(strategyOrBundleId: number, isBundle: boolean | undefined, triggerData: {
+        baseTokenAddress: EthereumAddress;
+        quoteTokenAddress: EthereumAddress;
+        price: number;
+        ratioState: RatioState;
+    }, subData: {
+        collAsset: EthereumAddress;
+        collAssetId: number;
+        debtAsset: EthereumAddress;
+        debtAssetId: number;
+    }): (number | boolean | string[])[];
+};
+export declare const compoundV3Encode: {
+    leverageManagement(market: EthereumAddress, baseToken: EthereumAddress, repayFrom: number, boostFrom: number, boostTo: number, repayTo: number, boostEnabled: boolean, isEOA: boolean): string[];
+};