@gearbox-protocol/sdk 14.12.0-next.2 → 14.12.0-next.20

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

@@ -1,4 +1,3 @@
-import { ierc4626AdapterAbi } from "@gearbox-protocol/integrations-v3";
 import { encodeFunctionData, getContract } from "viem";
 import {
   iBotListV310Abi,
@@ -7,12 +6,10 @@ import {
 import { creditAccountCompressorAbi } from "../../abi/compressors/creditAccountCompressor.js";
 import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
 import { rewardsCompressorAbi } from "../../abi/compressors/rewardsCompressor.js";
-import { iWithdrawalCompressorV310Abi } from "../../abi/IWithdrawalCompressorV310.js";
-import { iWithdrawalCompressorV311Abi } from "../../abi/IWithdrawalCompressorV311.js";
 import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
+import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
 import { iRWAFactoryAbi } from "../../abi/rwa/iRWAFactory.js";
 import { SDKConstruct } from "../base/index.js";
-import { chains } from "../chain/chains.js";
 import {
   ADDRESS_0X0,
   AP_CREDIT_ACCOUNT_COMPRESSOR,
@@ -27,27 +24,13 @@ import {
 import {
   getRawPriceUpdates
 } from "../market/index.js";
-import { assetsMap } from "../router/index.js";
-import { AddressMap, AddressSet, hexEq } from "../utils/index.js";
+import { AddressMap, AddressSet, AssetsMap, hexEq } from "../utils/index.js";
 import { simulateWithPriceUpdates } from "../utils/viem/index.js";
 import {
   extractPriceUpdates,
   extractQuotaTokens,
   mergePriceUpdates
 } from "./multicall-utils.js";
-const COMPRESSORS = {
-  [chains.Mainnet.id]: {
-    address: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
-    version: 310
-  },
-  [chains.Monad.id]: {
-    address: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
-    version: 310
-  }
-};
-function getWithdrawalCompressorAddress(chainId) {
-  return COMPRESSORS[chainId];
-}
 class CreditAccountsServiceV310 extends SDKConstruct {
   #compressor;
   #batchSize;
@@ -616,14 +599,12 @@ class CreditAccountsServiceV310 extends SDKConstruct {
       creditManager: cm.creditManager,
       slippage
     });
-    const operationCalls = [
-      ...routerCloseResult.calls,
-      ...this.#prepareDisableQuotas(ca),
-      ...this.#prepareDecreaseDebt(ca),
-      ...assetsToWithdraw.map(
-        (t) => this.#prepareWithdrawToken(ca.creditFacade, t, MAX_UINT256, to)
-      )
-    ];
+    const operationCalls = await this.assembleCloseCreditAccountCalls({
+      creditAccount: ca,
+      routerCalls: routerCloseResult.calls,
+      assetsToWithdraw,
+      to
+    });
     const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
     const tx = await this.#closeCreditAccountTx(
       cm,
@@ -633,6 +614,32 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     );
     return { tx, calls, routerCloseResult, creditFacade: cm.creditFacade };
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleCloseCreditAccountCalls}
+   */
+  async assembleCloseCreditAccountCalls({
+    creditAccount: ca,
+    routerCalls,
+    assetsToWithdraw,
+    to
+  }) {
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    await this.sdk.tokensMeta.loadTokenData(cm.underlying);
+    const underlying = this.sdk.tokensMeta.mustGet(cm.underlying);
+    if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) {
+      throw new Error(
+        "closeCreditAccount is not supported for RWA underlying credit accounts"
+      );
+    }
+    return [
+      ...routerCalls,
+      ...this.#prepareDisableQuotas(ca),
+      ...this.#prepareDecreaseDebt(ca),
+      ...assetsToWithdraw.map(
+        (t) => this.#prepareWithdrawToken(ca.creditFacade, t, MAX_UINT256, to)
+      )
+    ];
+  }
   /**
    * {@inheritDoc ICreditAccountsService.updateQuotas}
    **/
@@ -774,22 +781,8 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     amount,
     token
   }) {
-    const compressor = getWithdrawalCompressorAddress(this.sdk.chainId);
-    if (!compressor)
-      throw new Error(
-        `No compressor for current chain ${this.sdk.networkType}`
-      );
-    const contract = getContract({
-      address: compressor.address,
-      abi: compressor.version === 310 ? iWithdrawalCompressorV310Abi : iWithdrawalCompressorV311Abi,
-      client: this.client
-    });
-    const resp = await contract.read.getWithdrawalRequestResult([
-      creditAccount,
-      token,
-      amount
-    ]);
-    return resp;
+    const compressor = this.sdk.withdrawalCompressor();
+    return compressor.getWithdrawalRequestResult(creditAccount, token, amount);
   }
   /**
    * {@inheritDoc ICreditAccountsService.getPendingWithdrawals}
@@ -797,26 +790,12 @@ class CreditAccountsServiceV310 extends SDKConstruct {
   async getPendingWithdrawals({
     creditAccount
   }) {
-    const compressor = getWithdrawalCompressorAddress(this.sdk.chainId);
-    if (!compressor)
-      throw new Error(
-        `No compressor for current chain ${this.sdk.networkType}`
-      );
-    const contract = getContract({
-      address: compressor.address,
-      abi: compressor.version === 310 ? iWithdrawalCompressorV310Abi : iWithdrawalCompressorV311Abi,
-      client: this.client
-    });
-    const resp = await contract.read.getCurrentWithdrawals([creditAccount]);
-    const claimableNow = resp?.[0] || [];
-    const pendingResult = [...resp?.[1] || []].sort(
-      (a, b) => a.claimableAt < b.claimableAt ? -1 : 1
-    );
-    const respResult = {
-      claimableNow: [...claimableNow],
-      pending: pendingResult
+    const compressor = this.sdk.withdrawalCompressor();
+    const { claimable, pending } = await compressor.getCurrentWithdrawals(creditAccount);
+    return {
+      claimableNow: claimable,
+      pending
     };
-    return respResult;
   }
   /**
    * {@inheritDoc ICreditAccountsService.startDelayedWithdrawal}
@@ -1302,8 +1281,23 @@ class CreditAccountsServiceV310 extends SDKConstruct {
   /**
    * {@inheritDoc ICreditAccountsService.repayCreditAccount}
    */
-  async repayCreditAccount({
-    operation,
+  async repayCreditAccount(props) {
+    const { operation, creditAccount: ca } = props;
+    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+    const operationCalls = await this.assembleRepayCreditAccountCalls(props);
+    const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
+    const tx = await this.#closeCreditAccountTx(
+      cm,
+      ca.creditAccount,
+      calls,
+      operation
+    );
+    return { tx, calls, creditFacade: cm.creditFacade };
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleRepayCreditAccountCalls}
+   */
+  async assembleRepayCreditAccountCalls({
     collateralAssets,
     assetsToWithdraw,
     creditAccount: ca,
@@ -1312,7 +1306,6 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     tokensToClaim,
     calls: wrapCalls = []
   }) {
-    const cm = this.sdk.marketRegister.findCreditManager(ca.creditManager);
     const addCollateral = collateralAssets.filter((a) => a.balance > 0);
     const router = this.sdk.routerFor(ca);
     const unwrapCalls = await this.getRedeemDiffCalls(1n, ca.creditManager) ?? [];
@@ -1331,14 +1324,7 @@ class CreditAccountsServiceV310 extends SDKConstruct {
         (t) => this.#prepareWithdrawToken(ca.creditFacade, t.token, MAX_UINT256, to)
       )
     ];
-    const calls = operation === "close" ? operationCalls : await this.#prependPriceUpdates(ca.creditManager, operationCalls, ca);
-    const tx = await this.#closeCreditAccountTx(
-      cm,
-      ca.creditAccount,
-      calls,
-      operation
-    );
-    return { tx, calls, creditFacade: cm.creditFacade };
+    return operationCalls;
   }
   /**
    * {@inheritDoc ICreditAccountsService.repayAndLiquidateCreditAccount}
@@ -1559,19 +1545,13 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     );
   }
   /**
-   * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
+   * {@inheritDoc ICreditAccountsService.assembleCaOperations}
    */
-  assembleCaUpdateCalls({
+  assembleCaOperations({
     operations,
-    routerCallGroups,
-    creditFacade,
-    withdrawTo,
-    creditAccount,
-    underlyingToken
+    creditFacade
   }) {
     const calls = [];
-    let swapGroupIndex = 0;
-    let routerGroupsConsumed = 0;
     for (const op of operations) {
       switch (op.type) {
         case "increaseDebt":
@@ -1595,22 +1575,15 @@ class CreditAccountsServiceV310 extends SDKConstruct {
               creditFacade,
               op.token,
               op.amount,
-              withdrawTo
+              op.to
             )
           );
           break;
-        case "swap": {
-          const routerCalls = routerCallGroups[swapGroupIndex];
-          if (!routerCalls) {
-            throw new Error(
-              `assembleCaUpdateCalls: missing router calls for swap leg ${swapGroupIndex}`
-            );
-          }
-          calls.push(...routerCalls);
-          swapGroupIndex += 1;
-          routerGroupsConsumed += 1;
+        case "swap":
+        case "wrapRwaCollateral":
+        case "unwrapRwaCollateral":
+          calls.push(...op.calls);
           break;
-        }
         case "changeQuota": {
           const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
           if (quotaAssets.length === 0) {
@@ -1624,58 +1597,14 @@ class CreditAccountsServiceV310 extends SDKConstruct {
           );
           break;
         }
-        case "closeCreditAccount": {
-          for (const group of routerCallGroups) {
-            calls.push(...group);
-            routerGroupsConsumed += 1;
-          }
-          calls.push(
-            ...this.#prepareDisableQuotas({
-              creditFacade,
-              tokens: Object.entries(creditAccount.initialQuotas).map(
-                ([token, { quota }]) => ({
-                  token,
-                  quota
-                })
-              )
-            })
-          );
-          if (creditAccount.debt > 0n) {
-            calls.push(
-              ...this.#prepareDecreaseDebt({
-                creditFacade,
-                debt: creditAccount.debt
-              })
-            );
-          }
-          const hasAssets = creditAccount.assets.some(
-            (asset) => asset.balance > 0n
-          );
-          if (hasAssets) {
-            calls.push(
-              this.#prepareWithdrawToken(
-                creditFacade,
-                underlyingToken,
-                MAX_UINT256,
-                withdrawTo
-              )
-            );
-          }
-          break;
-        }
         default: {
           const _exhaustive = op;
           throw new Error(
-            `assembleCaUpdateCalls: unsupported operation ${_exhaustive}`
+            `assembleCaOperations: unsupported operation ${JSON.stringify(_exhaustive)}`
           );
         }
       }
     }
-    if (routerGroupsConsumed !== routerCallGroups.length) {
-      throw new Error(
-        `assembleCaUpdateCalls: router call group mismatch (consumed ${routerGroupsConsumed}, got ${routerCallGroups.length})`
-      );
-    }
     return calls;
   }
   /**
@@ -1718,10 +1647,10 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     return calls;
   }
   #prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
-    const minRecord = assetsMap(minQuota);
+    const minRecord = new AssetsMap(minQuota);
     const calls = averageQuota.map((q) => {
-      const minAsset = minRecord.get(q.token);
-      const min = minAsset && minAsset?.balance > 0 ? minAsset.balance : 0n;
+      const minBalance = minRecord.get(q.token);
+      const min = minBalance && minBalance > 0n ? minBalance : 0n;
       return {
         target: creditFacade,
         callData: encodeFunctionData({
@@ -1900,6 +1829,5 @@ class CreditAccountsServiceV310 extends SDKConstruct {
   }
 }
 export {
-  CreditAccountsServiceV310,
-  getWithdrawalCompressorAddress
+  CreditAccountsServiceV310
 };

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

@@ -1,2 +1,3 @@
 export * from "./CreditAccountsServiceV310.js";
 export * from "./types.js";
+export * from "./withdrawal-compressor/index.js";

package/dist/esm/sdk/accounts/withdrawal-compressor/AbstractWithdrawalCompressorContract.js

@@ -0,0 +1,200 @@
+import { isAddressEqual } from "viem";
+import { BaseContract } from "../../base/index.js";
+import { decodeDelayedIntent, encodeDelayedIntent } from "./intent-codec.js";
+const iCreditAccountAbi = [
+  {
+    type: "function",
+    name: "creditManager",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+class AbstractWithdrawalCompressorContract extends BaseContract {
+  #sdk;
+  constructor(sdk, args) {
+    super(sdk, args);
+    this.#sdk = sdk;
+  }
+  /**
+   * The contract is instantiated with the actual versioned ABI,
+   * this cast is type-level only (see {@link CommonAbi}).
+   **/
+  get common() {
+    return this.contract;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawableAssets}
+   **/
+  async getWithdrawableAssets(creditManager) {
+    const resp = await this.common.read.getWithdrawableAssets([creditManager]);
+    return resp.map((a) => toWithdrawableAsset(a, creditManager));
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawableAssetsBatch}
+   **/
+  async getWithdrawableAssetsBatch(creditManagers) {
+    const cms = creditManagers ?? this.#sdk.marketRegister.creditManagers.map(
+      (cm) => cm.creditManager.address
+    );
+    const resp = await this.client.multicall({
+      contracts: cms.map(
+        (cm) => ({
+          address: this.address,
+          abi: this.abi,
+          functionName: "getWithdrawableAssets",
+          args: [cm]
+        })
+      ),
+      allowFailure: true,
+      batchSize: 0
+    });
+    return resp.flatMap((r, i) => {
+      if (r.status !== "success") {
+        this.logger?.warn(
+          `failed to get withdrawable assets of credit manager ${cms[i]}: ${r.error}`
+        );
+        return [];
+      }
+      return r.result.map((a) => toWithdrawableAsset(a, cms[i]));
+    });
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getCurrentWithdrawals}
+   **/
+  async getCurrentWithdrawals(creditAccount) {
+    const [[claimable, pending], creditManager] = await this.client.multicall({
+      contracts: [
+        {
+          address: this.address,
+          abi: this.abi,
+          functionName: "getCurrentWithdrawals",
+          args: [creditAccount]
+        },
+        {
+          address: creditAccount,
+          abi: iCreditAccountAbi,
+          functionName: "creditManager"
+        }
+      ],
+      allowFailure: false,
+      batchSize: 0
+    });
+    return {
+      claimable: claimable.map(
+        (w) => toClaimableWithdrawal(w, creditManager, this.version >= 313)
+      ),
+      pending: pending.map(toPendingWithdrawal).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+    };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalRequestResult}
+   **/
+  async getWithdrawalRequestResult(creditAccount, token, amount, intent) {
+    const resp = intent ? await this.#getWithdrawalRequestResultWithIntent(
+      creditAccount,
+      token,
+      amount,
+      intent
+    ) : await this.common.read.getWithdrawalRequestResult([
+      creditAccount,
+      token,
+      amount
+    ]);
+    return {
+      token: resp.token,
+      amountIn: resp.amountIn,
+      outputs: resp.outputs.map(toWithdrawalOutput),
+      requestCalls: resp.requestCalls.map(toMultiCall),
+      claimableAt: resp.claimableAt
+    };
+  }
+  /**
+   * Previews a delayed withdrawal request with an intent attached as
+   * `extraData`. Only supported on v313+ compressors; on older versions,
+   * throws if `sdk.strictContractTypes` is `true`, otherwise logs a warning
+   * and previews the request without the intent.
+   *
+   * The contract overload accepting `extraData` also requires the withdrawal
+   * phantom token, which is resolved here the same way the 3-arg overload
+   * does it internally: via `getWithdrawableAssets` of the account's credit
+   * manager.
+   **/
+  async #getWithdrawalRequestResultWithIntent(creditAccount, token, amount, intent) {
+    if (this.version < 313) {
+      const message = `withdrawal intents are not supported by ${this.name} v${this.version}`;
+      if (this.#sdk.strictContractTypes) {
+        throw new Error(message);
+      }
+      this.logger?.warn(`${message}, requesting withdrawal without intent`);
+      return this.common.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        amount
+      ]);
+    }
+    const extraData = encodeDelayedIntent(intent);
+    const creditManager = await this.client.readContract({
+      address: creditAccount,
+      abi: iCreditAccountAbi,
+      functionName: "creditManager"
+    });
+    const assets = await this.common.read.getWithdrawableAssets([
+      creditManager
+    ]);
+    const asset = assets.find((a) => isAddressEqual(a.token, token));
+    if (!asset) {
+      throw new Error(
+        `token ${token} is not withdrawable from credit manager ${creditManager}`
+      );
+    }
+    return this.common.read.getWithdrawalRequestResult([
+      creditAccount,
+      token,
+      asset.withdrawalPhantomToken,
+      amount,
+      extraData
+    ]);
+  }
+}
+function toWithdrawalOutput(o) {
+  return { token: o.token, isDelayed: o.isDelayed, amount: o.amount };
+}
+function toMultiCall(c) {
+  return { target: c.target, callData: c.callData };
+}
+function toWithdrawableAsset(a, creditManager) {
+  return {
+    creditManager,
+    token: a.token,
+    withdrawalPhantomToken: a.withdrawalPhantomToken,
+    underlying: a.underlying,
+    withdrawalLength: a.withdrawalLength,
+    maxWithdrawals: a.maxWithdrawals
+  };
+}
+function toClaimableWithdrawal(w, creditManager, decodeIntent) {
+  let intent;
+  if (decodeIntent && w.extraData && w.extraData !== "0x") {
+    intent = { ...decodeDelayedIntent(w.extraData), creditManager };
+  }
+  return {
+    token: w.token,
+    withdrawalPhantomToken: w.withdrawalPhantomToken,
+    withdrawalTokenSpent: w.withdrawalTokenSpent,
+    outputs: w.outputs.map(toWithdrawalOutput),
+    claimCalls: w.claimCalls.map(toMultiCall),
+    intent
+  };
+}
+function toPendingWithdrawal(w) {
+  return {
+    token: w.token,
+    withdrawalPhantomToken: w.withdrawalPhantomToken,
+    expectedOutputs: w.expectedOutputs.map(toWithdrawalOutput),
+    claimableAt: w.claimableAt
+  };
+}
+export {
+  AbstractWithdrawalCompressorContract
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV310Contract.js

@@ -0,0 +1,16 @@
+import { iWithdrawalCompressorV310Abi } from "../../../abi/IWithdrawalCompressorV310.js";
+import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
+const abi = iWithdrawalCompressorV310Abi;
+class WithdrawalCompressorV310Contract extends AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV310",
+      abi,
+      version: 310
+    });
+  }
+}
+export {
+  WithdrawalCompressorV310Contract
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV311Contract.js

@@ -0,0 +1,16 @@
+import { iWithdrawalCompressorV311Abi } from "../../../abi/IWithdrawalCompressorV311.js";
+import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
+const abi = iWithdrawalCompressorV311Abi;
+class WithdrawalCompressorV311Contract extends AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV311",
+      abi,
+      version: 311
+    });
+  }
+}
+export {
+  WithdrawalCompressorV311Contract
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV313Contract.js

@@ -0,0 +1,16 @@
+import { iWithdrawalCompressorV313Abi } from "../../../abi/IWithdrawalCompressorV313.js";
+import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
+const abi = iWithdrawalCompressorV313Abi;
+class WithdrawalCompressorV313Contract extends AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV313",
+      abi,
+      version: 313
+    });
+  }
+}
+export {
+  WithdrawalCompressorV313Contract
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/addresses.js

@@ -0,0 +1,28 @@
+const WITHDRAWAL_COMPRESSORS = {
+  Mainnet: {
+    310: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023",
+    313: "0x9605D59E40963ADce8a6895Aa3Fa497320Ef3F3b"
+  },
+  Monad: {
+    310: "0x36F3d0Bb73CBC2E94fE24dF0f26a689409cF9023"
+  }
+};
+function getWithdrawalCompressorAddress(network, version) {
+  const deployments = WITHDRAWAL_COMPRESSORS[network];
+  if (!deployments) {
+    return void 0;
+  }
+  if (version !== void 0) {
+    const address2 = deployments[version];
+    return address2 ? { address: address2, version } : void 0;
+  }
+  const latest = Object.keys(deployments).map(Number).sort((a, b) => b - a)[0];
+  if (latest === void 0) {
+    return void 0;
+  }
+  const address = deployments[latest];
+  return address ? { address, version: latest } : void 0;
+}
+export {
+  getWithdrawalCompressorAddress
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/createWithdrawalCompressor.js

@@ -0,0 +1,29 @@
+import { getWithdrawalCompressorAddress } from "./addresses.js";
+import { WithdrawalCompressorV310Contract } from "./WithdrawalCompressorV310Contract.js";
+import { WithdrawalCompressorV311Contract } from "./WithdrawalCompressorV311Contract.js";
+import { WithdrawalCompressorV313Contract } from "./WithdrawalCompressorV313Contract.js";
+function createWithdrawalCompressor(sdk, version) {
+  const location = getWithdrawalCompressorAddress(sdk.networkType, version);
+  if (!location) {
+    throw new Error(
+      `no withdrawal compressor${version ? ` v${version}` : ""} on ${sdk.networkType}`
+    );
+  }
+  const cached = sdk.getContract(
+    location.address
+  );
+  if (cached) {
+    return cached;
+  }
+  switch (location.version) {
+    case 310:
+      return new WithdrawalCompressorV310Contract(sdk, location.address);
+    case 311:
+      return new WithdrawalCompressorV311Contract(sdk, location.address);
+    case 313:
+      return new WithdrawalCompressorV313Contract(sdk, location.address);
+  }
+}
+export {
+  createWithdrawalCompressor
+};

package/dist/esm/sdk/accounts/withdrawal-compressor/index.js

@@ -0,0 +1,8 @@
+export * from "./AbstractWithdrawalCompressorContract.js";
+export * from "./addresses.js";
+export * from "./createWithdrawalCompressor.js";
+export * from "./intent-codec.js";
+export * from "./types.js";
+export * from "./WithdrawalCompressorV310Contract.js";
+export * from "./WithdrawalCompressorV311Contract.js";
+export * from "./WithdrawalCompressorV313Contract.js";