@defisaver/automation-sdk 1.0.1

package/src/index.ts

@@ -0,0 +1,38 @@
+// 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 * as enums from './types/enums';
+import type * as types from './types';
+
+import { getRatioStateInfoForAaveCloseStrategy, compareSubHashes, encodeSubId } from './services/utils';
+
+const utils = {
+  getRatioStateInfoForAaveCloseStrategy, compareSubHashes, encodeSubId,
+};
+
+export {
+  LegacyMakerAutomation, LegacyAaveAutomation, LegacyCompoundAutomation,
+  EthereumStrategies, OptimismStrategies, ArbitrumStrategies,
+  triggerService, subDataService, strategySubService, utils,
+  enums, constants,
+};
+
+export type { types };

package/src/services/contractService.ts

@@ -0,0 +1,65 @@
+import type Web3 from 'web3';
+import type { AbiItem } from 'web3-utils';
+import type {
+  BlockNumber, Contract,
+} from '../types';
+
+import type { BaseContract } from '../types/contracts/generated/types';
+import type { Legacy_AuthCheck, SubStorage, UniMulticall } from '../types/contracts/generated';
+
+import { UniMulticallJson, SubStorageJson, AuthCheckJson } from '../abis';
+
+import { isDefined } from './utils';
+import { ChainId } from '../types/enums';
+
+export function getAbiItem(abi: AbiItem[], itemName: string) {
+  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<T extends BaseContract>(
+  web3: Web3,
+  contractJson: Contract.Json,
+  chainId: ChainId,
+): Contract.WithMeta<T> {
+  const { abi } = contractJson;
+
+  let _address = '';
+  let _createdBlock: BlockNumber = '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) as any as T,
+  };
+}
+
+export function makeUniMulticallContract(web3: Web3, chainId: ChainId) {
+  return makeContract<UniMulticall>(web3, UniMulticallJson, chainId);
+}
+
+export function makeSubStorageContract(web3: Web3, chainId: ChainId) {
+  return makeContract<SubStorage>(web3, SubStorageJson, chainId);
+}
+
+export function makeAuthCheckerContract(web3: Web3, chainId: ChainId) {
+  return makeContract<Legacy_AuthCheck>(web3, AuthCheckJson, chainId);
+}
+
+export function makeLegacySubscriptionContract<T extends BaseContract>(web3: Web3, contractJson: Contract.Json) {
+  return makeContract<T>(web3, contractJson, ChainId.Ethereum);
+}

package/src/services/ethereumService.ts

@@ -0,0 +1,55 @@
+import type Web3 from 'web3';
+import type { PastEventOptions } from 'web3-eth-contract';
+import type {
+  BlockNumber, Multicall, Contract,
+} from '../types';
+
+import { makeUniMulticallContract } from './contractService';
+import { addToObjectIf, isDefined } from './utils';
+import type { BaseContract } from '../types/contracts/generated/types';
+import type { ChainId } from '../types/enums';
+
+const { mockedWeb3 } = process;
+
+export async function multicall(
+  web3: Web3,
+  chainId: ChainId,
+  calls: Multicall.Calls[],
+  block: BlockNumber = 'latest',
+): Promise<Multicall.Payload> {
+  const multicallContract = makeUniMulticallContract(web3, chainId).contract;
+
+  const formattedCalls: Multicall.FormattedCalls[] = calls.map((call) => ({
+    callData: mockedWeb3.eth.abi.encodeFunctionCall(call.abiItem, call.params),
+    target: call.target || '0x0',
+    gasLimit: call.gasLimit || 1e6,
+  }));
+
+  const callResult = await multicallContract.methods.multicall(
+    formattedCalls.filter(item => item.target !== '0x0'),
+  ).call({}, block);
+
+  let formattedResult: Multicall.Payload = [];
+
+  callResult.returnData.forEach(([success, gasUsed, result], i) => {
+    const formattedRes = (result !== '0x'
+      ? mockedWeb3.eth.abi.decodeParameters(calls[i].abiItem.outputs!, result)
+      : undefined) as Multicall.Payload;
+    formattedResult = [...formattedResult, formattedRes];
+  });
+
+  return formattedResult;
+}
+
+export function getEventsFromContract<T extends BaseContract>(
+  contractWithMeta: Contract.WithMeta<T>,
+  event: string, options?: PastEventOptions,
+) {
+  return contractWithMeta.contract.getPastEvents(
+    event,
+    {
+      ...addToObjectIf(isDefined(options), options),
+      fromBlock: contractWithMeta.createdBlock,
+    },
+  );
+}

package/src/services/strategiesService.ts

@@ -0,0 +1,336 @@
+import { cloneDeep } from 'lodash';
+
+import { BUNDLES_INFO, STRATEGIES_INFO } from '../constants';
+import type {
+  Position, ParseData, StrategiesToProtocolVersionMapping, BundleOrStrategy, StrategyOrBundleIds,
+} from '../types';
+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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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 as Strategies.Identifiers);
+
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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: Position.Automated, parseData: ParseData): Position.Automated {
+  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, // Unknown minOptimalRatio, uses all assets from chicken bond until trove min debt (2000LUSD)
+    repayEnabled: true,
+  };
+  return _position;
+}
+
+const parsingMethodsMapping: StrategiesToProtocolVersionMapping = {
+  [ProtocolIdentifiers.StrategiesAutomation.MakerDAO]: {
+    [Strategies.Identifiers.SavingsLiqProtection]: parseMakerSavingsLiqProtection, // TODO union type by protocol
+    [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: ProtocolIdentifiers.StrategiesAutomation, strategy: BundleOrStrategy) {
+  return parsingMethodsMapping[id][strategy.strategyId];
+}
+
+export function parseStrategiesAutomatedPosition(parseData: ParseData): Position.Automated | null {
+  const { chainId, subscriptionEventData, strategiesSubsData } = parseData;
+  const { subStruct, proxy, subId } = subscriptionEventData;
+  const { isEnabled } = strategiesSubsData;
+
+  const id = subStruct.strategyOrBundleId as StrategyOrBundleIds;
+
+  const strategyOrBundleInfo = (
+    subStruct.isBundle
+      ? BUNDLES_INFO[chainId][id]
+      : STRATEGIES_INFO[chainId][id]
+  ) as BundleOrStrategy;
+
+  if (!strategyOrBundleInfo) return null;
+
+  const position: Position.Automated = {
+    isEnabled,
+    chainId,
+    subId: Number(subId),
+    owner: proxy,
+    protocol: {
+      ...strategyOrBundleInfo.protocol,
+    },
+    strategy: {
+      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/src/services/strategySubService.ts

@@ -0,0 +1,202 @@
+import Dec from 'decimal.js';
+import { getAssetInfo } from '@defisaver/tokens';
+
+import {
+  Bundles, ChainId, RatioState, Strategies,
+} from '../types/enums';
+import type { EthereumAddress, StrategyOrBundleIds } from '../types';
+
+import * as subDataService from './subDataService';
+import * as triggerService from './triggerService';
+import { compareAddresses, requireAddress, requireAddresses } from './utils';
+
+export const makerEncode = {
+  repayFromSavings(
+    bundleId: StrategyOrBundleIds,
+    vaultId: number,
+    priceOverOrUnder: RatioState,
+    targetRatio: number,
+    chainId: ChainId = ChainId.Ethereum,
+    isBundle: boolean = true,
+    daiAddr?: EthereumAddress,
+    mcdCdpManagerAddr?: EthereumAddress,
+  ) {
+    const subData = subDataService.makerRepayFromSavingsSubData.encode(vaultId, targetRatio, chainId, daiAddr, mcdCdpManagerAddr);
+    const triggerData = triggerService.makerRatioTrigger.encode(vaultId, priceOverOrUnder, RatioState.UNDER);
+
+    return [bundleId, isBundle, triggerData, subData];
+  },
+  closeOnPrice(
+    vaultId: number,
+    ratioState: RatioState,
+    price: string,
+    closeToAssetAddr: EthereumAddress,
+    chainlinkCollAddress: EthereumAddress,
+    chainId: ChainId = ChainId.Ethereum,
+    daiAddr?: EthereumAddress,
+    mcdCdpManagerAddr?: EthereumAddress,
+  ) {
+    requireAddresses([closeToAssetAddr, chainlinkCollAddress]);
+
+    const subData = subDataService.makerCloseSubData.encode(vaultId, closeToAssetAddr, chainId, daiAddr, mcdCdpManagerAddr);
+    const triggerData = triggerService.chainlinkPriceTrigger.encode(chainlinkCollAddress, price, ratioState);
+
+    const strategyOrBundleId = compareAddresses(closeToAssetAddr, getAssetInfo('DAI', chainId).address)
+      ? Strategies.MainnetIds.MAKER_CLOSE_ON_PRICE_TO_DAI
+      : Strategies.MainnetIds.MAKER_CLOSE_ON_PRICE_TO_COLL;
+
+    const isBundle = false;
+
+    return [strategyOrBundleId, isBundle, triggerData, subData];
+  },
+  trailingStop(
+    vaultId: number,
+    triggerPercentage: number,
+    closeToAssetAddr: EthereumAddress,
+    chainlinkCollAddress: EthereumAddress,
+    roundId: number,
+    chainId: ChainId = ChainId.Ethereum,
+    daiAddr?: EthereumAddress,
+    mcdCdpManagerAddr?: EthereumAddress,
+  ) {
+    requireAddresses([closeToAssetAddr, chainlinkCollAddress]);
+
+    const subData = subDataService.makerCloseSubData.encode(vaultId, closeToAssetAddr, chainId, daiAddr, mcdCdpManagerAddr);
+    const triggerData = triggerService.trailingStopTrigger.encode(chainlinkCollAddress, triggerPercentage, roundId);
+
+    const strategyOrBundleId = compareAddresses(closeToAssetAddr, getAssetInfo('DAI').address)
+      ? Strategies.MainnetIds.MAKER_TRAILING_STOP_LOSS_TO_DAI
+      : Strategies.MainnetIds.MAKER_TRAILING_STOP_LOSS_TO_COLL;
+
+    const isBundle = false;
+
+    return [strategyOrBundleId, isBundle, triggerData, subData];
+  },
+};
+
+export const liquityEncode = {
+  closeOnPrice(
+    priceOverOrUnder: RatioState,
+    price: string,
+    closeToAssetAddr: EthereumAddress,
+    chainlinkCollAddress: EthereumAddress,
+    chainId: ChainId = ChainId.Ethereum,
+    collAddr?: EthereumAddress,
+    debtAddr?: EthereumAddress,
+  ) {
+    requireAddresses([closeToAssetAddr, chainlinkCollAddress]);
+
+    const subData = subDataService.liquityCloseSubData.encode(closeToAssetAddr, chainId, collAddr, debtAddr);
+    const triggerData = triggerService.chainlinkPriceTrigger.encode(chainlinkCollAddress, price, priceOverOrUnder);
+
+    const strategyOrBundleId = Strategies.MainnetIds.LIQUITY_CLOSE_ON_PRICE_TO_COLL;
+
+    const isBundle = false;
+
+    return [strategyOrBundleId, isBundle, triggerData, subData];
+  },
+  trailingStop(
+    triggerPercentage: number,
+    closeToAssetAddr: EthereumAddress,
+    chainlinkCollAddress: EthereumAddress,
+    roundId: number,
+    chainId: ChainId = ChainId.Ethereum,
+    collAddr?: EthereumAddress,
+    debtAddr?: EthereumAddress,
+  ) {
+    requireAddresses([closeToAssetAddr, chainlinkCollAddress]);
+
+    const subData = subDataService.liquityCloseSubData.encode(closeToAssetAddr, chainId, collAddr, debtAddr);
+    const triggerData = triggerService.trailingStopTrigger.encode(chainlinkCollAddress, triggerPercentage, roundId);
+
+    const strategyOrBundleId = Strategies.MainnetIds.LIQUITY_TRAILING_STOP_LOSS_TO_COLL;
+
+    const isBundle = false;
+
+    return [strategyOrBundleId, isBundle, triggerData, subData];
+  },
+  paybackFromChickenBondStrategySub(
+    proxyAddress: EthereumAddress,
+    ratio: number,
+    sourceId: string,
+    sourceType: number,
+    ratioState: RatioState = RatioState.UNDER,
+  ) {
+    requireAddress(proxyAddress);
+    const subData = subDataService.liquityPaybackUsingChickenBondSubData.encode(sourceId, sourceType);
+    const triggerData = triggerService.liquityRatioTrigger.encode(proxyAddress, ratio, ratioState);
+
+    const strategyId = Bundles.MainnetIds.LIQUITY_PAYBACK_USING_CHICKEN_BOND;
+
+    const isBundle = true;
+
+    return [strategyId, isBundle, triggerData, subData];
+  },
+};
+
+export const chickenBondsEncode = {
+  rebond(bondId: number) {
+    return subDataService.cBondsRebondSubData.encode(bondId);
+  },
+};
+
+export const aaveV3Encode = {
+  leverageManagement(
+    minRatio: number,
+    maxRatio: number,
+    maxOptimalRatio: number,
+    minOptimalRatio: number,
+    boostEnabled: boolean,
+  ) {
+    let subInput = '0x';
+
+    subInput = subInput.concat(new Dec(minRatio).mul(1e16).toHex().slice(2)
+      .padStart(32, '0'));
+    subInput = subInput.concat(new Dec(maxRatio).mul(1e16).toHex().slice(2)
+      .padStart(32, '0'));
+    subInput = subInput.concat(new Dec(maxOptimalRatio).mul(1e16).toHex().slice(2)
+      .padStart(32, '0'));
+    subInput = subInput.concat(new Dec(minOptimalRatio).mul(1e16).toHex().slice(2)
+      .padStart(32, '0'));
+    subInput = subInput.concat(boostEnabled ? '01' : '00');
+
+    return subInput;
+  },
+  closeToAsset(
+    strategyOrBundleId: number,
+    isBundle: boolean = true,
+    triggerData: {
+      baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: number, ratioState: RatioState
+    },
+    subData: {
+      collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number,
+    },
+  ) {
+    const {
+      collAsset, collAssetId, debtAsset, debtAssetId,
+    } = subData;
+    const subDataEncoded = subDataService.aaveV3QuotePriceSubData.encode(collAsset, collAssetId, debtAsset, debtAssetId);
+
+    const {
+      baseTokenAddress, quoteTokenAddress, price, ratioState,
+    } = triggerData;
+    const triggerDataEncoded = triggerService.aaveV3QuotePriceTrigger.encode(baseTokenAddress, quoteTokenAddress, price, ratioState);
+
+    return [strategyOrBundleId, isBundle, triggerDataEncoded, subDataEncoded];
+  },
+};
+
+export const compoundV3Encode = {
+  leverageManagement(
+    market: EthereumAddress,
+    baseToken: EthereumAddress,
+    repayFrom: number,
+    boostFrom: number,
+    boostTo: number,
+    repayTo: number,
+    boostEnabled: boolean,
+    isEOA: boolean,
+  ) {
+    return subDataService.compoundV3LeverageManagementSubData.encode(market, baseToken, repayFrom, boostFrom, boostTo, repayTo, boostEnabled, isEOA);
+  },
+};