@gearbox-protocol/sdk 14.12.0-next.1 → 14.12.0-next.11

package/dist/esm/plugins/adapters/contracts/PendleRouterAdapterContract.js

@@ -1,5 +1,7 @@
 import { iPendleRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -94,6 +96,64 @@ class PendleRouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokenForPt":
+      case "addLiquiditySingleTokenDiff": {
+        const [, , , diffInput] = decoded.args;
+        return [
+          {
+            tokenIn: diffInput.tokenIn,
+            leftoverAmount: diffInput.leftoverTokenIn
+          }
+        ];
+      }
+      case "swapDiffPtForToken": {
+        const [market, leftoverPt] = decoded.args;
+        const pt = this.#mustFindPendleToken(market, 0 /* PT */);
+        return [{ tokenIn: pt, leftoverAmount: leftoverPt }];
+      }
+      case "removeLiquiditySingleTokenDiff": {
+        const [market, leftoverLp] = decoded.args;
+        const lp = this.#mustFindPendleToken(market, 1 /* LP */);
+        return [{ tokenIn: lp, leftoverAmount: leftoverLp }];
+      }
+      case "redeemDiffPyToToken": {
+        const candidates = this.allowedPairs.filter(
+          (p) => (p.pendleTokenType === void 0 || p.pendleTokenType === 0 /* PT */) && (balances.get(p.pendleToken) ?? 0n) > 1n
+        );
+        const ptTokens = new Set(
+          candidates.map((p) => p.pendleToken.toLowerCase())
+        );
+        if (ptTokens.size !== 1) {
+          throw new Error(
+            `cannot recover PT token for redeemDiffPyToToken on pendle adapter at ${this.address}: ${ptTokens.size} candidates`
+          );
+        }
+        const [, leftoverPt] = decoded.args;
+        return [
+          {
+            tokenIn: candidates[0].pendleToken,
+            leftoverAmount: leftoverPt
+          }
+        ];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
+  #mustFindPendleToken(market, type) {
+    const marketLC = market.toLowerCase();
+    const pair = this.allowedPairs.find(
+      (p) => p.market.toLowerCase() === marketLC && (p.pendleTokenType === void 0 || p.pendleTokenType === type)
+    );
+    if (!pair) {
+      throw new Error(
+        `pendle pair for market ${market} not found on adapter at ${this.address}`
+      );
+    }
+    return pair.pendleToken;
+  }
 }
 export {
   PendlePairStatus,

package/dist/esm/plugins/adapters/contracts/SecuritizeOnRampAdapterContract.js

@@ -1,4 +1,6 @@
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -43,6 +45,17 @@ class SecuritizeOnRampAdapterContract extends AbstractAdapterContract {
       liquidityToken: this.#liquidityToken ? this.labelAddress(this.#liquidityToken) : void 0
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      // swaps the liquidity token into dsToken
+      case "swapDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.liquidityToken, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   SecuritizeOnRampAdapterContract

package/dist/esm/plugins/adapters/contracts/SecuritizeSwapAdapterContract.js

@@ -1,9 +1,21 @@
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
-const abi = [];
+const abi = [
+  {
+    type: "function",
+    name: "buyExactInDiff",
+    inputs: [
+      { name: "leftoverAmount", type: "uint256", internalType: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  }
+];
 const protocolAbi = [];
 class SecuritizeSwapAdapterContract extends AbstractAdapterContract {
   #dsToken;
@@ -40,6 +52,17 @@ class SecuritizeSwapAdapterContract extends AbstractAdapterContract {
       stableCoinToken: this.#stableCoinToken ? this.labelAddress(this.#stableCoinToken) : void 0
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      // buys dsToken with the stablecoin
+      case "buyExactInDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stableCoinToken, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   SecuritizeSwapAdapterContract

package/dist/esm/plugins/adapters/contracts/StakingRewardsAdapterContract.js

@@ -1,5 +1,7 @@
 import { iStakingRewardsAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -79,6 +81,23 @@ class StakingRewardsAdapterContract extends AbstractAdapterContract {
       referral: this.#referral
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "stakeDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stakingToken, leftoverAmount }];
+      }
+      case "withdrawDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stakedPhantomToken, leftoverAmount }];
+      }
+      // no accrued rewards on a freshly opened account
+      case "getReward":
+        return [];
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   StakingRewardsAdapterContract

package/dist/esm/plugins/adapters/contracts/TraderJoeRouterAdapterContract.js

@@ -1,5 +1,7 @@
 import { iTraderJoeRouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import { MissingSerializedParamsError } from "../../../sdk/index.js";
 import { iTraderJoeRouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -58,6 +60,16 @@ class TraderJoeRouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokensForTokens": {
+        const [leftoverAmount, , path] = decoded.args;
+        return [{ tokenIn: path.tokenPath[0], leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   TraderJoePoolVersion,

package/dist/esm/plugins/adapters/contracts/UniswapV2AdapterContract.js

@@ -72,6 +72,16 @@ class UniswapV2AdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...swapFromTransfers(transfers) };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokensForTokens": {
+        const [leftoverAmount, , path] = decoded.args;
+        return [{ tokenIn: path[0], leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   UniswapV2AdapterContract

package/dist/esm/plugins/adapters/contracts/UniswapV3AdapterContract.js

@@ -50,6 +50,26 @@ class UniswapV3AdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "exactDiffInputSingle": {
+        const [params] = decoded.args;
+        return [
+          {
+            tokenIn: params.tokenIn,
+            leftoverAmount: params.leftoverAmount
+          }
+        ];
+      }
+      case "exactDiffInput": {
+        const [params] = decoded.args;
+        const tokenIn = `0x${params.path.replace("0x", "").slice(0, 40)}`;
+        return [{ tokenIn, leftoverAmount: params.leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
   stringifyFunctionParams(params) {
     switch (params.functionName) {
       case "exactInputSingle": {

package/dist/esm/plugins/adapters/contracts/UniswapV4AdapterContract.js

@@ -2,7 +2,9 @@ import {
   iUniswapV4AdapterAbi,
   iUniswapV4GatewayAbi
 } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import { MissingSerializedParamsError } from "../../../sdk/index.js";
 import { swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -61,6 +63,21 @@ class UniswapV4AdapterContract extends AbstractAdapterContract {
   classifyLegacyOperation(_parsed, transfers) {
     return { operation: "UniswapSwap", ...swapFromTransfers(transfers) };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapExactInputSingleDiff": {
+        const [poolKey, zeroForOne, leftoverAmount] = decoded.args;
+        return [
+          {
+            tokenIn: zeroForOne ? poolKey.token0 : poolKey.token1,
+            leftoverAmount
+          }
+        ];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   UniswapV4AdapterContract

package/dist/esm/plugins/adapters/contracts/UpshiftVaultAdapterContract.js

@@ -2,7 +2,9 @@ import {
   iUpshiftVaultAdapterAbi,
   iUpshiftVaultGatewayAbi
 } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -52,6 +54,20 @@ class UpshiftVaultAdapterContract extends AbstractAdapterContract {
       stakedPhantomToken: this.#stakedPhantomToken ? this.labelAddress(this.#stakedPhantomToken) : void 0
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "depositDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.asset, leftoverAmount }];
+      }
+      case "redeemDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.vault, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   UpshiftVaultAdapterContract

package/dist/esm/plugins/adapters/contracts/VelodromeV2AdapterContract.js

@@ -1,5 +1,7 @@
 import { iVelodromeV2RouterAdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import { MissingSerializedParamsError } from "../../../sdk/index.js";
 import { iVelodromeV2RouterAbi } from "../abi/targetContractAbi.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";
@@ -51,6 +53,16 @@ class VelodromeV2RouterAdapterContract extends AbstractAdapterContract {
       }))
     };
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "swapDiffTokensForTokens": {
+        const [leftoverAmount, , routes] = decoded.args;
+        return [{ tokenIn: routes[0].from, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   VelodromeV2RouterAdapterContract

package/dist/esm/plugins/adapters/contracts/WstETHV1AdapterContract.js

@@ -1,5 +1,7 @@
 import { iwstEthv1AdapterAbi } from "@gearbox-protocol/integrations-v3";
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import {
   MissingSerializedParamsError
 } from "../../../sdk/index.js";
@@ -44,6 +46,21 @@ class WstETHV1AdapterContract extends AbstractAdapterContract {
     }
     return super.classifyLegacyOperation(parsed, transfers);
   }
+  decodeDiffLeftovers(decoded, balances) {
+    switch (decoded.functionName) {
+      case "wrapDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.stETH, leftoverAmount }];
+      }
+      // wstETH is the adapter's target contract
+      case "unwrapDiff": {
+        const [leftoverAmount] = decoded.args;
+        return [{ tokenIn: this.targetContract, leftoverAmount }];
+      }
+      default:
+        return super.decodeDiffLeftovers(decoded, balances);
+    }
+  }
 }
 export {
   WstETHV1AdapterContract

package/dist/esm/preview/index.js

@@ -1,4 +1,3 @@
-export * from "./parse/index.js";
 export * from "./prerequisites/index.js";
-export * from "./simulate/index.js";
+export * from "./preview/index.js";
 export * from "./trace/index.js";

package/dist/esm/preview/parse/classifyInnerOperations.js

@@ -12,7 +12,8 @@ function classifyInnerOperations(calls, props) {
         version: call.version,
         label: call.label,
         adapterFunctionName: call.functionName,
-        adapterArgs: call.rawArgs
+        adapterArgs: call.rawArgs,
+        calldata: call.calldata
       });
       continue;
     }
@@ -59,6 +60,18 @@ function classifyFacadeInnerCall(call, underlying) {
         token: rawArgs.token,
         change: rawArgs.quotaChange
       };
+    case "storeExpectedBalances": {
+      const balanceDeltas = rawArgs.balanceDeltas;
+      return {
+        operation: "StoreExpectedBalances",
+        deltas: balanceDeltas.map(({ token, amount }) => ({
+          token,
+          balance: amount
+        }))
+      };
+    }
+    case "compareBalances":
+      return { operation: "CompareBalances" };
     default:
       return null;
   }

package/dist/esm/preview/parse/errors.js

@@ -1,3 +1,4 @@
+import { UnsupportedZapperFunctionError } from "../../sdk/index.js";
 class UnsupportedTargetError extends Error {
   target;
   constructor(target) {
@@ -18,5 +19,6 @@ class UnsupportedPoolFunctionError extends Error {
 }
 export {
   UnsupportedPoolFunctionError,
-  UnsupportedTargetError
+  UnsupportedTargetError,
+  UnsupportedZapperFunctionError
 };

package/dist/esm/preview/parse/index.js

@@ -1,7 +1,7 @@
 export * from "./classifyInnerOperations.js";
 export * from "./errors.js";
-export * from "./extractExpectedBalanceChanges.js";
 export * from "./parseFacadeOperationCalldata.js";
 export * from "./parseOperationCalldata.js";
 export * from "./parsePoolOperationCalldata.js";
+export * from "./parseRWAFactoryOperationCalldata.js";
 export * from "./types.js";

package/dist/esm/preview/parse/parseFacadeOperationCalldata.js

@@ -1,6 +1,5 @@
 import { isAddressEqual, zeroAddress } from "viem";
 import { classifyInnerOperations } from "./classifyInnerOperations.js";
-import { extractExpectedBalanceChanges } from "./extractExpectedBalanceChanges.js";
 function parseFacadeOperationCalldata(props) {
   const { sdk, facade, calldata } = props;
   const parsed = sdk.parseFunctionDataV2(facade.address, calldata);
@@ -21,23 +20,20 @@ function parseFacadeOperationCalldata(props) {
     sdk,
     underlying: suite.underlying
   });
-  const expectedBalanceChanges = extractExpectedBalanceChanges(innerCalls);
   switch (functionName) {
     case "multicall":
       return {
         ...metadata,
         operation: "MultiCall",
         creditAccount: rawArgs.creditAccount,
-        multicall,
-        expectedBalanceChanges
+        multicall
       };
     case "botMulticall":
       return {
         ...metadata,
         operation: "BotMulticall",
         creditAccount: rawArgs.creditAccount,
-        multicall,
-        expectedBalanceChanges
+        multicall
       };
     case "openCreditAccount":
       return {
@@ -46,16 +42,14 @@ function parseFacadeOperationCalldata(props) {
         creditAccount: zeroAddress,
         onBehalfOf: rawArgs.onBehalfOf,
         referralCode: rawArgs.referralCode,
-        multicall,
-        expectedBalanceChanges
+        multicall
       };
     case "closeCreditAccount":
       return {
         ...metadata,
         operation: "CloseCreditAccount",
         creditAccount: rawArgs.creditAccount,
-        multicall,
-        expectedBalanceChanges
+        multicall
       };
     case "liquidateCreditAccount":
       return {
@@ -67,8 +61,7 @@ function parseFacadeOperationCalldata(props) {
         // liquidation, so they are not recoverable from raw calldata.
         token: zeroAddress,
         remainingFunds: 0n,
-        multicall,
-        expectedBalanceChanges
+        multicall
       };
     case "partiallyLiquidateCreditAccount":
       return {

package/dist/esm/preview/parse/parseOperationCalldata.js

@@ -1,16 +1,50 @@
 import {
   CreditFacadeV310Contract,
-  PoolV310Contract
+  isRWAFactory,
+  PoolV310Contract,
+  ZapperContract
 } from "../../sdk/index.js";
 import { UnsupportedTargetError } from "./errors.js";
 import { parseFacadeOperationCalldata } from "./parseFacadeOperationCalldata.js";
 import { parsePoolOperationCalldata } from "./parsePoolOperationCalldata.js";
+import { parseRWAFactoryOperationCalldata } from "./parseRWAFactoryOperationCalldata.js";
 function parseOperationCalldata(input) {
-  const { sdk, to, calldata } = input;
+  const { sdk, to, calldata, value, sender } = input;
   const contract = sdk.getContract(to);
   if (contract instanceof PoolV310Contract) {
     return parsePoolOperationCalldata({ sdk, pool: contract, calldata });
   }
+  if (contract instanceof ZapperContract) {
+    const parsed = contract.parseOperation(calldata, value);
+    if (parsed.operation === "Deposit") {
+      const op2 = {
+        operation: "Deposit",
+        pool: parsed.pool,
+        receiver: parsed.receiver,
+        assets: parsed.assets,
+        underlying: parsed.underlying,
+        tokenIn: contract.tokenIn.addr,
+        tokenOut: contract.tokenOut.addr,
+        zapper: parsed.zapper,
+        referralCode: parsed.referralCode
+      };
+      return op2;
+    }
+    const op = {
+      operation: "Redeem",
+      pool: parsed.pool,
+      receiver: parsed.receiver,
+      // The zapper burns the caller's share tokens, so the share owner is the
+      // transaction sender.
+      owner: sender,
+      shares: parsed.shares,
+      underlying: parsed.underlying,
+      tokenIn: contract.tokenOut.addr,
+      tokenOut: contract.tokenIn.addr,
+      zapper: parsed.zapper
+    };
+    return op;
+  }
   if (contract instanceof CreditFacadeV310Contract) {
     return parseFacadeOperationCalldata({
       sdk,
@@ -18,6 +52,13 @@ function parseOperationCalldata(input) {
       calldata
     });
   }
+  if (contract && isRWAFactory(contract)) {
+    return parseRWAFactoryOperationCalldata({
+      sdk,
+      factory: contract,
+      calldata
+    });
+  }
   throw new UnsupportedTargetError(to);
 }
 export {

package/dist/esm/preview/parse/parsePoolOperationCalldata.js

@@ -14,6 +14,9 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         assets: rawArgs.assets,
         underlying,
+        tokenIn: underlying,
+        tokenOut: pool.address,
+        zapper: void 0,
         referralCode: functionName === "depositWithReferral" ? rawArgs.referralCode : void 0
       };
     case "mint":
@@ -24,6 +27,9 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         shares: rawArgs.shares,
         underlying,
+        tokenIn: underlying,
+        tokenOut: pool.address,
+        zapper: void 0,
         referralCode: functionName === "mintWithReferral" ? rawArgs.referralCode : void 0
       };
     case "withdraw":
@@ -33,7 +39,10 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         owner: rawArgs.owner,
         assets: rawArgs.assets,
-        underlying
+        underlying,
+        tokenIn: pool.address,
+        tokenOut: underlying,
+        zapper: void 0
       };
     case "redeem":
       return {
@@ -42,7 +51,10 @@ function parsePoolOperationCalldata(props) {
         receiver: rawArgs.receiver,
         owner: rawArgs.owner,
         shares: rawArgs.shares,
-        underlying
+        underlying,
+        tokenIn: pool.address,
+        tokenOut: underlying,
+        zapper: void 0
       };
     default:
       throw new UnsupportedPoolFunctionError(pool.address, parsed.functionName);

package/dist/esm/preview/parse/parseRWAFactoryOperationCalldata.js

@@ -0,0 +1,85 @@
+import { AbstractAdapterContract } from "../../plugins/adapters/index.js";
+import {
+  CreditFacadeV310Contract,
+  hexEq,
+  isRWAFactory,
+  RWA_FACTORY_SECURITIZE
+} from "../../sdk/index.js";
+import { classifyInnerOperations } from "./classifyInnerOperations.js";
+function parseRWAFactoryOperationCalldata(props) {
+  const { contractType, address } = props.factory;
+  if (isRWAFactory(props.factory, RWA_FACTORY_SECURITIZE)) {
+    return parseSecuritizeOperationCalldata(props);
+  }
+  throw new Error(
+    `unsupported RWA factory type "${contractType}" on ${address}`
+  );
+}
+function parseSecuritizeOperationCalldata(props) {
+  const { sdk, factory, calldata } = props;
+  const parsed = sdk.parseFunctionDataV2(factory.address, calldata);
+  const functionName = parsed.functionName.split("(")[0];
+  const { rawArgs } = parsed;
+  const innerCalls = rawArgs.calls ?? [];
+  const tokensToRegister = [
+    ...rawArgs.tokensToRegister ?? []
+  ];
+  const signaturesToCache = [
+    ...rawArgs.signaturesToCache ?? []
+  ];
+  const suite = functionName === "openCreditAccount" ? sdk.marketRegister.findCreditManager(rawArgs.creditManager) : resolveSuiteForMulticall(sdk, factory, innerCalls);
+  const metadata = {
+    factory: factory.address,
+    creditManager: suite.creditManager.address,
+    creditFacade: suite.creditFacade.address
+  };
+  const multicall = classifyInnerOperations(innerCalls, {
+    sdk,
+    underlying: suite.underlying
+  });
+  switch (functionName) {
+    case "openCreditAccount":
+      return {
+        ...metadata,
+        operation: "SecuritizeOpenCreditAccount",
+        multicall,
+        tokensToRegister,
+        signaturesToCache
+      };
+    case "multicall":
+      return {
+        ...metadata,
+        operation: "SecuritizeMulticall",
+        creditAccount: rawArgs.creditAccount,
+        multicall,
+        tokensToRegister,
+        signaturesToCache
+      };
+    default:
+      throw new Error(
+        `unsupported RWA factory function "${parsed.functionName}" on ${factory.address}`
+      );
+  }
+}
+function resolveSuiteForMulticall(sdk, factory, innerCalls) {
+  for (const call of innerCalls) {
+    const contract = sdk.getContract(call.target);
+    if (contract instanceof CreditFacadeV310Contract) {
+      const suite = sdk.marketRegister.creditManagers.find(
+        (cm) => hexEq(cm.creditFacade.address, call.target)
+      );
+      if (suite) {
+        return suite;
+      }
+    }
+    if (contract instanceof AbstractAdapterContract) {
+      return sdk.marketRegister.findCreditManager(contract.creditManager);
+    }
+  }
+  throw new Error(
+    `cannot resolve credit manager for RWA factory multicall on ${factory.address}`
+  );
+}
+export {
+  parseRWAFactoryOperationCalldata
+};