@defisaver/automation-sdk 1.0.1

package/src/automation/private/LegacyAutomation.ts

@@ -0,0 +1,124 @@
+import type Web3 from 'web3';
+import type {
+  EthereumAddress, Position, Interfaces, Contract, PlaceholderType,
+} from '../../types';
+import type {
+  Legacy_AaveV2Subscriptions, Legacy_CompoundV2Subscriptions, Legacy_MakerSubscriptions, Legacy_AuthCheck,
+} from '../../types/contracts/generated';
+
+import { getAbiItem, makeAuthCheckerContract } from '../../services/contractService';
+import { multicall } from '../../services/ethereumService';
+import { isAddress, isUndefined } from '../../services/utils';
+
+import Automation from './Automation';
+import { ChainId, ProtocolIdentifiers } from '../../types/enums';
+
+export default class LegacyAutomation extends Automation {
+  protected chainId: ChainId = ChainId.Ethereum;
+
+  protected web3: Web3;
+
+  protected monitorAddress: EthereumAddress;
+
+  protected subscriptionsContract: Contract.WithMeta<Legacy_MakerSubscriptions | Legacy_AaveV2Subscriptions | Legacy_CompoundV2Subscriptions>;
+
+  protected authCheckerContract: Contract.WithMeta<Legacy_AuthCheck>;
+
+  protected protocol: Interfaces.LegacyProtocol;
+
+  constructor(args: Interfaces.LegacyAutomation<Legacy_MakerSubscriptions | Legacy_AaveV2Subscriptions | Legacy_CompoundV2Subscriptions>) {
+    super();
+
+    this.web3 = args.provider;
+    this.subscriptionsContract = args.subscriptionsJson;
+    this.monitorAddress = args.monitorAddress;
+    this.protocol = args.protocol;
+    this.authCheckerContract = makeAuthCheckerContract(this.web3, this.chainId);
+
+    this.assertLegacy();
+  }
+
+  protected assertSubscriptionContract() {
+    if (isUndefined(this.subscriptionsContract)) {
+      throw new Error(`Assertion for property 'subscriptionsContract' failed. \nGot: '${this.subscriptionsContract}.`);
+    }
+  }
+
+  protected assertProtocol() {
+    if (isUndefined(this.protocol)) {
+      throw new Error(`Assertion for property 'protocol' failed. \nGot: '${this.protocol}.`);
+    }
+  }
+
+  protected assertMonitorAddress() {
+    if (!isAddress(this.monitorAddress)) {
+      throw new Error(`Assertion for property 'monitorAddress' failed. \nGot: '${this.monitorAddress}.`);
+    }
+  }
+
+  protected assertLegacy() {
+    this.assertProtocol();
+    this.assertMonitorAddress();
+    this.assertSubscriptionContract();
+    this.assert();
+  }
+
+  protected async isMonitorAuthorized(address: EthereumAddress, caller: EthereumAddress): Promise<boolean> {
+    return this.authCheckerContract.contract.methods.canCall(caller, address, '0x1cff79cd').call();
+  }
+
+  protected async isMonitorAuthorizedMulticall(addresses: EthereumAddress[], caller: EthereumAddress): Promise<boolean[]> {
+    const authCheckerContract = this.authCheckerContract;
+
+    const defaultOptions = {
+      target: authCheckerContract.address,
+      abiItem: getAbiItem(authCheckerContract.abi, 'canCall'),
+    };
+
+    const multicallCalls = addresses.map((addr) => ({ ...defaultOptions, params: [caller, addr, '0x1cff79cd'] }));
+
+    return (await multicall(this.web3, this.chainId, multicallCalls)).map(res => res[0]);
+  }
+
+
+  // Aave and Compound use 'user' for property name
+  private getOwnerPropName() {
+    return this.protocol.id === ProtocolIdentifiers.LegacyAutomation.MakerDAO ? 'owner' : 'user';
+  }
+
+  protected async _getSubscriptions(addresses?: EthereumAddress[]): Promise<PlaceholderType> { // TODO PlaceholderType
+    let subscriptions = await this.subscriptionsContract.contract.methods.getSubscribers().call();
+
+    if (addresses) {
+      const _addresses = addresses.map(a => a.toLowerCase());
+
+      // @ts-ignore
+      subscriptions = subscriptions.filter(s => _addresses.includes(s[this.getOwnerPropName()]));
+    }
+
+    return subscriptions;
+  }
+
+  protected async getParsedSubscriptions(addresses?: EthereumAddress[]): Promise<Position.LegacyAutomated[]> {
+    let subscriptions = await this._getSubscriptions(addresses);
+
+    // @ts-ignore
+    subscriptions = subscriptions.map(sub => ({
+      chainId: this.chainId,
+      owner: sub[this.getOwnerPropName()],
+      isEnabled: true,
+      protocol: this.protocol,
+      specific: { ...sub },
+    }));
+
+    return subscriptions;
+  }
+
+  public async getSubscriptions(): Promise<Position.LegacyAutomated[]> {
+    return this.getParsedSubscriptions();
+  }
+
+  public async getSubscriptionsFor(addresses: EthereumAddress[]): Promise<Position.LegacyAutomated[]> {
+    return this.getParsedSubscriptions(addresses);
+  }
+}

package/src/automation/private/LegacyProtocol.ts

@@ -0,0 +1,45 @@
+import type { Interfaces } from '../../types';
+import type { ProtocolIdentifiers } from '../../types/enums';
+
+export default class Protocol implements Interfaces.LegacyProtocol {
+  id: ProtocolIdentifiers.LegacyAutomation;
+
+  name: string;
+
+  version: string;
+
+  fullName: string;
+
+  #versionSeparator = '__';
+
+  constructor(args: { id: ProtocolIdentifiers.LegacyAutomation }) {
+    this.id = args.id;
+
+    this.name = this.getName();
+    this.version = this.getVersion();
+    this.fullName = this.getFullName();
+  }
+
+  private hasVersion() {
+    return this.id.indexOf(this.#versionSeparator) !== -1;
+  }
+
+  private splitId() {
+    return this.id.split(this.#versionSeparator);
+  }
+
+  /**
+   * @dev See naming convention at ProtocolIdentifiers declaration
+   */
+  private getVersion() {
+    return this.hasVersion() ? this.splitId().reverse()[0] : '';
+  }
+
+  private getName() {
+    return this.hasVersion() ? this.splitId()[0] : this.id;
+  }
+
+  private getFullName() {
+    return this.hasVersion() ? `${this.name} ${this.version}` : this.name;
+  }
+}

package/src/automation/private/Protocol.ts

@@ -0,0 +1,45 @@
+import type { Interfaces } from '../../types';
+import type { ProtocolIdentifiers } from '../../types/enums';
+
+export default class Protocol implements Interfaces.Protocol {
+  id: ProtocolIdentifiers.StrategiesAutomation;
+
+  name: string;
+
+  version: string;
+
+  fullName: string;
+
+  #versionSeparator = '__';
+
+  constructor(args: { id: ProtocolIdentifiers.StrategiesAutomation }) {
+    this.id = args.id;
+
+    this.name = this.getName();
+    this.version = this.getVersion();
+    this.fullName = this.getFullName();
+  }
+
+  private hasVersion() {
+    return this.id.indexOf(this.#versionSeparator) !== -1;
+  }
+
+  private splitId() {
+    return this.id.split(this.#versionSeparator);
+  }
+
+  /**
+   * @dev See naming convention at ProtocolIdentifiers declaration
+   */
+  private getVersion() {
+    return this.hasVersion() ? this.splitId().reverse()[0] : '';
+  }
+
+  private getName() {
+    return this.hasVersion() ? this.splitId()[0] : this.id;
+  }
+
+  private getFullName() {
+    return this.hasVersion() ? `${this.name} ${this.version}` : this.name;
+  }
+}

package/src/automation/private/StrategiesAutomation.ts

@@ -0,0 +1,157 @@
+import type Web3 from 'web3';
+import type { PastEventOptions, Filter } from 'web3-eth-contract';
+import type {
+  Position, Interfaces, EthereumAddress,
+  SubscriptionOptions, Contract, ParseData, PlaceholderType,
+} from '../../types';
+import type {
+  Subscribe, StrategyModel, SubStorage, UpdateData,
+} from '../../types/contracts/generated/SubStorage';
+
+import {
+  addToArrayIf, addToObjectIf, isDefined,
+} from '../../services/utils';
+import { getAbiItem, makeSubStorageContract } from '../../services/contractService';
+import { getEventsFromContract, multicall } from '../../services/ethereumService';
+
+import Automation from './Automation';
+import { parseStrategiesAutomatedPosition } from '../../services/strategiesService';
+import type { ChainId } from '../../types/enums';
+
+interface IStrategiesAutomation extends Interfaces.Automation {
+  chainId: ChainId,
+}
+
+export default class StrategiesAutomation extends Automation {
+  protected chainId: ChainId;
+
+  protected web3: Web3;
+
+  protected subStorageContract: Contract.WithMeta<SubStorage>;
+
+  constructor(args: IStrategiesAutomation) {
+    super();
+
+    this.web3 = args.provider;
+    this.chainId = args.chainId;
+    this.subStorageContract = makeSubStorageContract(this.web3, this.chainId);
+
+    this.assert();
+  }
+
+  protected async getEventFromSubStorage(event: string, options?: PastEventOptions) {
+    return getEventsFromContract<SubStorage>(this.subStorageContract, event, options);
+  }
+
+  protected async getStrategiesSubs(subIds: number[]): Promise<StrategyModel.StoredSubDataStructOutputStruct[]> {
+    const subStorageContract = this.subStorageContract;
+
+    const defaultOptions = {
+      target: subStorageContract.address,
+      abiItem: getAbiItem(subStorageContract.abi, 'strategiesSubs'),
+    };
+
+    const multicallCalls = subIds.map((subId) => ({ ...defaultOptions, params: [subId] }));
+
+    return multicall(this.web3, this.chainId, multicallCalls);
+  }
+
+  protected async getSubscriptionEventsFromSubStorage(options?: PastEventOptions) {
+    return this.getEventFromSubStorage('Subscribe', options);
+  }
+
+  protected async getUpdateDataEventsFromSubStorage(options?: PastEventOptions) {
+    return this.getEventFromSubStorage('UpdateData', options);
+  }
+
+  protected getParsedSubscriptions(parseData: ParseData) {
+    return parseStrategiesAutomatedPosition(parseData);
+  }
+
+  protected async _getSubscriptions(addresses?: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]> {
+    const _options = {
+      ...addToObjectIf(isDefined(options), options),
+      ...addToObjectIf(isDefined(addresses), { filter: { proxy: addresses } }),
+    };
+
+    const subscriptionEvents = (await this.getSubscriptionEventsFromSubStorage(_options)).map(e => e.returnValues) as PlaceholderType; // TODO PlaceholderType
+
+    let subscriptions: (Position.Automated | null)[] = [];
+
+    if (subscriptionEvents) {
+      // @ts-ignore
+      const strategiesSubs = await this.getStrategiesSubs(subscriptionEvents.map((e) => e.subId));
+
+      subscriptions = await Promise.all(strategiesSubs.map(async (sub, index: number) => {
+        let latestUpdate = subscriptionEvents[index];
+
+        if (latestUpdate.subHash !== sub?.strategySubHash) {
+          const updates = await this.getUpdateDataEventsFromSubStorage({ filter: latestUpdate.subId as any as Filter });
+          latestUpdate = {
+            ...latestUpdate, // Update is missing proxy, hence this
+            ...updates?.[updates.length - 1]?.returnValues,
+          };
+        }
+        return this.getParsedSubscriptions({
+          chainId: this.chainId,
+          subscriptionEventData: latestUpdate,
+          strategiesSubsData: sub,
+        });
+      }));
+
+      if (options?.mergeWithSameId) {
+        subscriptions = subscriptions.reduce((list: (Position.Automated | null)[], current) => {
+          const copyList = [...list] as (Position.Automated | null)[];
+
+          if (isDefined(current)) {
+            if (current.specific.mergeWithSameId) {
+              const mergePairIndex = copyList.findIndex(s => (
+                s && s.specific.mergeWithSameId
+                && s.strategy.strategyId === current.strategy.strategyId
+                && s.protocol.id === current.protocol.id
+              ));
+
+              if (mergePairIndex !== -1) {
+                const mergePair = copyList[mergePairIndex];
+                if (isDefined(mergePair)) {
+                  copyList[mergePairIndex] = {
+                    ...mergePair,
+                    ...current,
+                    isEnabled: mergePair.isEnabled || current.isEnabled,
+                    subId: mergePair.subId,
+                    subIds: [...addToArrayIf(isDefined(mergePair.subIds), mergePair.subIds), current.subId],
+                    specific: {
+                      ...mergePair.specific,
+                      ...current.specific,
+                      mergeWithSameId: false,
+                    },
+                  };
+                  return copyList;
+                }
+              }
+            }
+          } else {
+            return copyList;
+          }
+
+          copyList.push({
+            ...current,
+            subIds: [current.subId],
+          });
+
+          return copyList;
+        }, []);
+      }
+    }
+
+    return subscriptions;
+  }
+
+  public async getSubscriptions(options?: SubscriptionOptions): Promise<(Position.Automated | null)[]> {
+    return this._getSubscriptions(undefined, options);
+  }
+
+  public async getSubscriptionsFor(addresses: EthereumAddress[], options?: SubscriptionOptions): Promise<(Position.Automated | null)[]> {
+    return this._getSubscriptions(addresses, options);
+  }
+}

package/src/automation/public/ArbitrumStrategies.ts

@@ -0,0 +1,10 @@
+import type { Interfaces } from '../../types';
+
+import StrategiesAutomation from '../private/StrategiesAutomation';
+import { ChainId } from '../../types/enums';
+
+export default class ArbitrumStrategies extends StrategiesAutomation {
+  constructor(args: Interfaces.Automation) {
+    super({ ...args, chainId: ChainId.Arbitrum });
+  }
+}

package/src/automation/public/EthereumStrategies.ts

@@ -0,0 +1,10 @@
+import type { Interfaces } from '../../types';
+
+import StrategiesAutomation from '../private/StrategiesAutomation';
+import { ChainId } from '../../types/enums';
+
+export default class EthereumStrategies extends StrategiesAutomation {
+  constructor(args: Interfaces.Automation) {
+    super({ ...args, chainId: ChainId.Ethereum });
+  }
+}

package/src/automation/public/OptimismStrategies.ts

@@ -0,0 +1,10 @@
+import type { Interfaces } from '../../types';
+
+import StrategiesAutomation from '../private/StrategiesAutomation';
+import { ChainId } from '../../types/enums';
+
+export default class OptimismStrategies extends StrategiesAutomation {
+  constructor(args: Interfaces.Automation) {
+    super({ ...args, chainId: ChainId.Optimism });
+  }
+}

package/src/automation/public/legacy/LegacyAaveAutomation.ts

@@ -0,0 +1,20 @@
+import type { Interfaces } from '../../../types';
+import type { Legacy_AaveV2Subscriptions } from '../../../types/contracts/generated';
+
+import { LEGACY_PROTOCOLS } from '../../../constants';
+import { AaveV2SubscriptionsJson } from '../../../abis';
+
+import { makeLegacySubscriptionContract } from '../../../services/contractService';
+
+import LegacyAutomation from '../../private/LegacyAutomation';
+
+export default class LegacyAaveAutomation extends LegacyAutomation {
+  constructor(args: Interfaces.LegacyAutomation<Legacy_AaveV2Subscriptions>) {
+    super({
+      provider: args.provider,
+      subscriptionsJson: makeLegacySubscriptionContract(args.provider, AaveV2SubscriptionsJson),
+      monitorAddress: '0x380982902872836ceC629171DaeAF42EcC02226e',
+      protocol: LEGACY_PROTOCOLS.AaveV2,
+    });
+  }
+}

package/src/automation/public/legacy/LegacyCompoundAutomation.ts

@@ -0,0 +1,20 @@
+import type { Interfaces } from '../../../types';
+import type { Legacy_CompoundV2Subscriptions } from '../../../types/contracts/generated';
+
+import { LEGACY_PROTOCOLS } from '../../../constants';
+import { CompoundV2SubscriptionsJson } from '../../../abis';
+
+import { makeLegacySubscriptionContract } from '../../../services/contractService';
+
+import LegacyAutomation from '../../private/LegacyAutomation';
+
+export default class LegacyAaveAutomation extends LegacyAutomation {
+  constructor(args: Interfaces.LegacyAutomation<Legacy_CompoundV2Subscriptions>) {
+    super({
+      provider: args.provider,
+      subscriptionsJson: makeLegacySubscriptionContract(args.provider, CompoundV2SubscriptionsJson),
+      monitorAddress: '0xB1cF8DE8e791E4Ed1Bd86c03E2fc1f14389Cb10a',
+      protocol: LEGACY_PROTOCOLS.CompoundV2,
+    });
+  }
+}

package/src/automation/public/legacy/LegacyMakerAutomation.ts

@@ -0,0 +1,20 @@
+import type { Interfaces } from '../../../types';
+import type { Legacy_MakerSubscriptions } from '../../../types/contracts/generated';
+
+import { LEGACY_PROTOCOLS } from '../../../constants';
+import { MakerSubscriptionsJson } from '../../../abis';
+
+import { makeLegacySubscriptionContract } from '../../../services/contractService';
+
+import LegacyAutomation from '../../private/LegacyAutomation';
+
+export default class LegacyMakerAutomation extends LegacyAutomation {
+  constructor(args: Interfaces.LegacyAutomation<Legacy_MakerSubscriptions>) {
+    super({
+      provider: args.provider,
+      subscriptionsJson: makeLegacySubscriptionContract(args.provider, MakerSubscriptionsJson),
+      monitorAddress: '0x1816A86C4DA59395522a42b871bf11A4E96A1C7a',
+      protocol: LEGACY_PROTOCOLS.MakerDAO,
+    });
+  }
+}

package/src/configuration.ts

@@ -0,0 +1,11 @@
+import Web3 from 'web3';
+import Dec from 'decimal.js';
+
+process.mockedWeb3 = new Web3('');
+
+Dec.set({
+  rounding: Dec.ROUND_DOWN,
+  toExpPos: 9e15,
+  toExpNeg: -9e15,
+  precision: 100,
+});

package/src/constants/index.ts

@@ -0,0 +1,173 @@
+import type {
+  ArbitrumBundleInfo, BundlesInfo, EthereumAddress, Interfaces, MainnetBundleInfo, MainnetStrategiesInfo, OptimismBundleInfo, StrategiesInfo,
+} from '../types';
+
+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: EthereumAddress = '0x0000000000000000000000000000000000000000';
+
+export const PROTOCOLS: Record<keyof typeof ProtocolIdentifiers.StrategiesAutomation, Interfaces.Protocol> = (() => {
+  const protocolsMapping: any = {};
+  Object.entries(ProtocolIdentifiers.StrategiesAutomation).forEach(([id, value]) => {
+    protocolsMapping[id] = new Protocol({ id: value });
+  });
+  return protocolsMapping;
+})();
+
+export const LEGACY_PROTOCOLS: Record<keyof typeof ProtocolIdentifiers.LegacyAutomation, Interfaces.LegacyProtocol> = (() => {
+  const protocolsMapping: any = {};
+  Object.entries(ProtocolIdentifiers.LegacyAutomation).forEach(([id, value]) => {
+    protocolsMapping[id] = new LegacyProtocol({ id: value });
+  });
+  return protocolsMapping;
+})();
+
+// Strategies info
+export const MAINNET_STRATEGIES_INFO: MainnetStrategiesInfo = {
+  [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: StrategiesInfo = {
+  [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: MainnetBundleInfo = {
+  [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: OptimismBundleInfo = {
+  [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: ArbitrumBundleInfo = {
+  [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: BundlesInfo = {
+  [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,
+};