@gearbox-protocol/sdk 8.3.2 → 8.4.0

package/dist/esm/sdk/accounts/CreditAccountsServiceV300.js

@@ -0,0 +1,351 @@
+import { parseAbi } from "abitype";
+import { encodeFunctionData } from "viem";
+import { NOT_DEPLOYED } from "../constants/addresses.js";
+import { MAX_UINT256 } from "../constants/math.js";
+import {
+  auraStakedTokens,
+  auraTokens,
+  contractsByNetwork,
+  convexStakedPhantomTokens,
+  convexTokens,
+  isAuraStakedToken,
+  isConvexStakedPhantomToken,
+  isStakingRewardsPhantomToken,
+  stakingRewardsTokens,
+  tokenDataByNetwork,
+  tokenSymbolByAddress
+} from "../sdk-gov-legacy/index.js";
+import { AbstractCreditAccountService } from "./AbstractCreditAccountsService.js";
+class CreditAccountServiceV300 extends AbstractCreditAccountService {
+  /**
+   * Implements {@link ICreditAccountsService.setBot}
+   */
+  setBot(_) {
+    throw new Error(
+      "Not implemented in router v3.0. Try direct call setBotPermissions instead."
+    );
+  }
+  /**
+   * Implements {@link ICreditAccountsService.withdrawCollateral}
+   */
+  async withdrawCollateral({
+    creditAccount,
+    assetsToWithdraw: wrapped,
+    to,
+    minQuota,
+    averageQuota
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      creditAccount.creditManager,
+      creditAccount,
+      void 0
+    );
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      false,
+      false,
+      creditAccount.creditManager
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...unwrapCalls,
+      ...assetsToWithdraw.map(
+        (a) => this.prepareWithdrawToken(
+          creditAccount.creditFacade,
+          a.token,
+          a.balance,
+          to
+        )
+      ),
+      ...this.prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
+    ];
+    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayCreditAccount}
+   */
+  async repayCreditAccount({
+    operation,
+    collateralAssets,
+    assetsToWithdraw: wrapped,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      true,
+      true,
+      ca.creditManager
+    );
+    const calls = [
+      ...operation === "close" ? [] : priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...this.prepareDisableQuotas(ca),
+      ...this.prepareDecreaseDebt(ca),
+      ...unwrapCalls,
+      ...this.prepareDisableTokens(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, MAX_UINT256, to)
+      )
+    ];
+    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayAndLiquidateCreditAccount}
+   */
+  async repayAndLiquidateCreditAccount({
+    collateralAssets,
+    assetsToWithdraw: wrapped,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const { unwrapCalls, assetsToWithdraw } = this.#prepareUnwrapAndWithdrawCallsV3(
+      wrapped,
+      true,
+      true,
+      ca.creditManager
+    );
+    const calls = [
+      ...priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...unwrapCalls,
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, MAX_UINT256, to)
+      )
+    ];
+    const tx = cm.creditFacade.liquidateCreditAccount(
+      ca.creditAccount,
+      to,
+      calls
+    );
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.claimFarmRewards}
+   */
+  async claimFarmRewards({
+    tokensToDisable,
+    calls: claimCalls,
+    creditAccount: ca,
+    minQuota,
+    averageQuota
+  }) {
+    if (claimCalls.length === 0) throw new Error("No path to execute");
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      averageQuota
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...claimCalls,
+      ...tokensToDisable.map(
+        (a) => this.prepareDisableToken(ca.creditFacade, a.token)
+      ),
+      ...this.prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
+    ];
+    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * unwraps staked tokens and optionally claims associated rewards; Should be remove after transition to 3.1
+   * @param acc
+   * @returns
+   */
+  #prepareUnwrapAndWithdrawCallsV3(assets, claim, withdrawAll, creditManager) {
+    const network = this.sdk.provider.networkType;
+    const suite = this.sdk.marketRegister.findCreditManager(creditManager);
+    const cmAdapters = suite.creditManager.adapters.values().reduce((acc, a) => {
+      const contractLc = a.targetContract.toLowerCase();
+      const adapterLc = a.address.toLowerCase();
+      acc[contractLc] = adapterLc;
+      return acc;
+    }, {});
+    const currentContractsData = Object.entries(
+      contractsByNetwork[network]
+    ).reduce(
+      (acc, [symbol, address]) => {
+        if (!!address && address !== NOT_DEPLOYED) {
+          acc[symbol] = address.toLowerCase();
+        }
+        return acc;
+      },
+      {}
+    );
+    const currentTokenData = Object.entries(tokenDataByNetwork[network]).reduce(
+      (acc, [symbol, address]) => {
+        if (!!address && address !== NOT_DEPLOYED) {
+          acc[symbol] = address.toLowerCase();
+        }
+        return acc;
+      },
+      {}
+    );
+    const { aura, convex, sky } = assets.reduce(
+      (acc, a) => {
+        const symbol = tokenSymbolByAddress[a.token];
+        if (isConvexStakedPhantomToken(symbol)) {
+          acc.convex.push(a);
+        } else if (isAuraStakedToken(symbol)) {
+          acc.aura.push(a);
+        } else if (isStakingRewardsPhantomToken(symbol)) {
+          acc.sky.push(a);
+        }
+        return acc;
+      },
+      { convex: [], aura: [], sky: [] }
+    );
+    const getWithdrawCall = (pool, a) => {
+      return withdrawAll ? this.#withdrawAllAndUnwrap_Convex(pool, claim) : this.#withdrawAndUnwrap_Convex(pool, a.balance, claim);
+    };
+    const getWithdrawCall_Rewards = (pool, a) => {
+      const calls = [
+        withdrawAll ? this.#withdrawAll_Rewards(pool) : this.#withdraw_Rewards(pool, a.balance),
+        ...claim ? [this.#claim_Rewards(pool)] : []
+      ];
+      return calls;
+    };
+    const convexStkCalls = convex.map((a) => {
+      const symbol = tokenSymbolByAddress[a.token];
+      const { pool } = convexTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (convex)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall(cmAdapters[poolAddressLc], a);
+    });
+    const auraStkCalls = aura.map((a) => {
+      const symbol = tokenSymbolByAddress[a.token];
+      const { pool } = auraTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (aura)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall(cmAdapters[poolAddressLc], a);
+    });
+    const skyStkCalls = sky.flatMap((a) => {
+      const symbol = tokenSymbolByAddress[a.token];
+      const { pool } = stakingRewardsTokens[symbol];
+      const poolAddress = currentContractsData[pool];
+      if (!poolAddress) {
+        throw new Error("Can't withdrawAllAndUnwrap_Convex (sky)");
+      }
+      const poolAddressLc = poolAddress.toLowerCase();
+      return getWithdrawCall_Rewards(cmAdapters[poolAddressLc], a);
+    });
+    const unwrapCalls = [...convexStkCalls, ...auraStkCalls, ...skyStkCalls];
+    const withdraw = assets.map((a) => {
+      const symbol = tokenSymbolByAddress[a.token];
+      if (isConvexStakedPhantomToken(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[convexStakedPhantomTokens[symbol].underlying]
+        };
+      }
+      if (isAuraStakedToken(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[auraStakedTokens[symbol].underlying]
+        };
+      }
+      if (isStakingRewardsPhantomToken(symbol)) {
+        return {
+          ...a,
+          token: currentTokenData[stakingRewardsTokens[symbol].underlying]
+        };
+      }
+      return a;
+    });
+    return { unwrapCalls, assetsToWithdraw: withdraw };
+  }
+  #withdrawAndUnwrap_Convex(address, amount, claim) {
+    return {
+      target: address,
+      callData: encodeFunctionData({
+        abi: parseAbi([
+          "function withdrawAndUnwrap(uint256, bool claim) returns (uint256 tokensToEnable, uint256 tokensToDisable)"
+        ]),
+        functionName: "withdrawAndUnwrap",
+        args: [amount, claim]
+      })
+    };
+  }
+  #withdrawAllAndUnwrap_Convex(address, claim) {
+    return {
+      target: address,
+      callData: encodeFunctionData({
+        abi: parseAbi([
+          "function withdrawDiffAndUnwrap(uint256 leftoverAmount, bool claim) returns (uint256 tokensToEnable, uint256 tokensToDisable)"
+        ]),
+        functionName: "withdrawDiffAndUnwrap",
+        args: [1n, claim]
+      })
+    };
+  }
+  #withdrawAll_Rewards(address) {
+    return {
+      target: address,
+      callData: encodeFunctionData({
+        abi: parseAbi([
+          "function withdrawDiff(uint256 leftoverAmount) external returns (bool useSafePrices)"
+        ]),
+        functionName: "withdrawDiff",
+        args: [1n]
+      })
+    };
+  }
+  #withdraw_Rewards(address, amount) {
+    return {
+      target: address,
+      callData: encodeFunctionData({
+        abi: parseAbi([
+          "function withdraw(uint256 amount) external returns (bool useSafePrices)"
+        ]),
+        functionName: "withdraw",
+        args: [amount]
+      })
+    };
+  }
+  #claim_Rewards(address) {
+    return {
+      target: address,
+      callData: encodeFunctionData({
+        abi: parseAbi([
+          "function getReward() external returns (bool useSafePrices)"
+        ]),
+        functionName: "getReward",
+        args: []
+      })
+    };
+  }
+}
+export {
+  CreditAccountServiceV300
+};

package/dist/esm/sdk/accounts/CreditAccountsServiceV310.js

@@ -0,0 +1,176 @@
+import { encodeFunctionData } from "viem";
+import { iCreditFacadeMulticallV310Abi } from "../../abi/v310.js";
+import { MAX_UINT256 } from "../constants/math.js";
+import { AbstractCreditAccountService } from "./AbstractCreditAccountsService.js";
+import { PERMISSION_BY_TYPE } from "./constants.js";
+class CreditAccountServiceV310 extends AbstractCreditAccountService {
+  /**
+   * Implements {@link ICreditAccountsService.setBot}
+   */
+  async setBot({
+    botAddress,
+    botBaseType,
+    stopBot,
+    creditAccount: ca
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const addBotCall = {
+      target: ca.creditFacade,
+      callData: encodeFunctionData({
+        abi: iCreditFacadeMulticallV310Abi,
+        functionName: "setBotPermissions",
+        args: [botAddress, stopBot ? 0n : PERMISSION_BY_TYPE[botBaseType]]
+      })
+    };
+    const calls = [...priceUpdatesCalls, addBotCall];
+    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.withdrawCollateral}
+   */
+  async withdrawCollateral({
+    creditAccount,
+    assetsToWithdraw,
+    to,
+    minQuota,
+    averageQuota
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      creditAccount.creditManager,
+      creditAccount,
+      void 0
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...assetsToWithdraw.map(
+        (a) => this.prepareWithdrawToken(
+          creditAccount.creditFacade,
+          a.token,
+          a.balance,
+          to
+        )
+      ),
+      ...this.prepareUpdateQuotas(creditAccount.creditFacade, {
+        minQuota,
+        averageQuota
+      })
+    ];
+    const tx = cm.creditFacade.multicall(creditAccount.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayCreditAccount}
+   */
+  async repayCreditAccount({
+    operation,
+    collateralAssets,
+    assetsToWithdraw,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const router = this.sdk.routerFor(ca);
+    const claimPath = await router.findClaimAllRewards({
+      calls: [],
+      creditAccount: ca
+    });
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const calls = [
+      ...operation === "close" ? [] : priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...this.prepareDisableQuotas(ca),
+      ...this.prepareDecreaseDebt(ca),
+      ...claimPath.calls,
+      ...this.prepareDisableTokens(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, MAX_UINT256, to)
+      )
+    ];
+    const tx = operation === "close" ? cm.creditFacade.closeCreditAccount(ca.creditAccount, calls) : cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.repayAndLiquidateCreditAccount}
+   */
+  async repayAndLiquidateCreditAccount({
+    collateralAssets,
+    assetsToWithdraw,
+    creditAccount: ca,
+    permits,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const router = this.sdk.routerFor(ca);
+    const claimPath = await router.findClaimAllRewards({
+      calls: [],
+      creditAccount: ca
+    });
+    const priceUpdates = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      void 0
+    );
+    const addCollateral = collateralAssets.filter((a) => a.balance > 0);
+    const calls = [
+      ...priceUpdates,
+      ...this.prepareAddCollateral(ca.creditFacade, addCollateral, permits),
+      ...claimPath.calls,
+      ...assetsToWithdraw.map(
+        (t) => this.prepareWithdrawToken(ca.creditFacade, t.token, MAX_UINT256, to)
+      )
+    ];
+    const tx = cm.creditFacade.liquidateCreditAccount(
+      ca.creditAccount,
+      to,
+      calls
+    );
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * Implements {@link ICreditAccountsService.claimFarmRewards}
+   */
+  async claimFarmRewards({
+    calls: legacyCalls,
+    creditAccount: ca,
+    minQuota,
+    averageQuota
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const router = this.sdk.routerFor(ca);
+    const claimPath = await router.findClaimAllRewards({
+      calls: legacyCalls,
+      creditAccount: ca
+    });
+    if (claimPath.calls.length === 0) throw new Error("No path to execute");
+    const priceUpdatesCalls = await this.getPriceUpdatesForFacade(
+      ca.creditManager,
+      ca,
+      averageQuota
+    );
+    const calls = [
+      ...priceUpdatesCalls,
+      ...claimPath.calls,
+      ...this.prepareUpdateQuotas(ca.creditFacade, { minQuota, averageQuota })
+    ];
+    const tx = cm.creditFacade.multicall(ca.creditAccount, calls);
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+}
+export {
+  CreditAccountServiceV310
+};

package/dist/esm/sdk/accounts/constants.js

@@ -0,0 +1,9 @@
+import { BotPermissions } from "../constants/bot-permissions.js";
+const PERMISSION_BY_TYPE = {
+  LIQUIDATION_PROTECTION: BigInt(
+    BotPermissions.ADD_COLLATERAL | BotPermissions.WITHDRAW_COLLATERAL | BotPermissions.DECREASE_DEBT
+  )
+};
+export {
+  PERMISSION_BY_TYPE
+};

package/dist/esm/sdk/accounts/createCreditAccountService.js

@@ -0,0 +1,15 @@
+import { isV300, isV310 } from "../constants/index.js";
+import { CreditAccountServiceV300 } from "./CreditAccountsServiceV300.js";
+import { CreditAccountServiceV310 } from "./CreditAccountsServiceV310.js";
+function createCreditAccountService(sdk, version) {
+  if (isV300(version)) {
+    return new CreditAccountServiceV300(sdk);
+  }
+  if (isV310(version)) {
+    return new CreditAccountServiceV310(sdk);
+  }
+  throw new Error(`Unsupported Credit Account Service version ${version}`);
+}
+export {
+  createCreditAccountService
+};

package/dist/esm/sdk/accounts/index.js

@@ -1,2 +1,3 @@
-export * from "./CreditAccountsService.js";
+export * from "./constants.js";
+export * from "./createCreditAccountService.js";
 export * from "./types.js";

package/dist/esm/sdk/router/RouterV300Contract.js

@@ -156,6 +156,14 @@ class RouterV300Contract extends AbstractRouterContract {
       calls: [...result.calls]
     };
   }
+  /**
+   * Implements {@link IRouterContract.findClaimAllRewards}
+   */
+  async findClaimAllRewards(props) {
+    return {
+      calls: props.calls
+    };
+  }
   /**
    * Implements {@link IRouterContract.findBestClosePath}
    */

package/dist/esm/sdk/router/RouterV310Contract.js

@@ -1,4 +1,4 @@
-import { getAddress } from "viem";
+import { encodeFunctionData, getAddress } from "viem";
 import { iGearboxRouterV310Abi } from "../../abi/routerV310.js";
 import { BigIntMath } from "../sdk-legacy/index.js";
 import { AddressMap } from "../utils/AddressMap.js";
@@ -118,6 +118,30 @@ class RouterV310Contract extends AbstractRouterContract {
       calls: [...result.calls]
     };
   }
+  /**
+   * Implements {@link IRouterContract.findClaimAllRewards}
+   */
+  async findClaimAllRewards(props) {
+    const tData = props.creditAccount.tokens.map((a) => ({
+      balance: a.balance,
+      claimRewards: true,
+      leftoverBalance: a.balance,
+      numSplits: 0n,
+      token: a.token
+    }));
+    return {
+      calls: [
+        {
+          target: this.address,
+          callData: encodeFunctionData({
+            abi: this.abi,
+            functionName: "processClaims",
+            args: [props.creditAccount.creditAccount, tData]
+          })
+        }
+      ]
+    };
+  }
   /**
    * Implements {@link IRouterContract.findBestClosePath}
    */

package/dist/types/abi/routerV310.d.ts

@@ -56,6 +56,54 @@ export declare const iGearboxRouterV310Abi: readonly [{
         readonly internalType: "bytes32[]";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "processClaims";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "tData";
+        readonly type: "tuple[]";
+        readonly internalType: "struct TokenData[]";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "balance";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "leftoverBalance";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "numSplits";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "claimRewards";
+            readonly type: "bool";
+            readonly internalType: "bool";
+        }];
+    }];
+    readonly outputs: readonly [{
+        readonly name: "calls";
+        readonly type: "tuple[]";
+        readonly internalType: "struct MultiCall[]";
+        readonly components: readonly [{
+            readonly name: "target";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "callData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
+        }];
+    }];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "routeManyToOne";

package/dist/types/dev/AccountOpener.d.ts

@@ -1,6 +1,6 @@
 import type { Address, Hash, PrivateKeyAccount } from "viem";
 import { BaseError } from "viem";
-import type { CreditAccountData, CreditAccountsService, RawTx } from "../sdk/index.js";
+import type { CreditAccountData, CreditAccountsServiceInstance, RawTx } from "../sdk/index.js";
 import { SDKConstruct } from "../sdk/index.js";
 export declare class OpenTxRevertedError extends BaseError {
     readonly txHash: Hash;
@@ -37,7 +37,7 @@ export interface OpenAccountResult {
 }
 export declare class AccountOpener extends SDKConstruct {
     #private;
-    constructor(service: CreditAccountsService, options?: AccountOpenerOptions);
+    constructor(service: CreditAccountsServiceInstance, options?: AccountOpenerOptions);
     get borrower(): Address;
     /**
      * Tries to open account with underlying only in each CM