@gearbox-protocol/sdk 14.12.0-next.4 → 14.12.0-next.41

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

@@ -0,0 +1,292 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var AbstractWithdrawalCompressorContract_exports = {};
+__export(AbstractWithdrawalCompressorContract_exports, {
+  AbstractWithdrawalCompressorContract: () => AbstractWithdrawalCompressorContract,
+  iCreditAccountAbi: () => iCreditAccountAbi,
+  toClaimableWithdrawal: () => toClaimableWithdrawal,
+  toPendingWithdrawal: () => toPendingWithdrawal,
+  toRequestableWithdrawal: () => toRequestableWithdrawal
+});
+module.exports = __toCommonJS(AbstractWithdrawalCompressorContract_exports);
+var import_viem = require("viem");
+var import_base = require("../../base/index.js");
+var import_utils = require("../../utils/index.js");
+var import_intent_codec = require("./intent-codec.js");
+const iCreditAccountAbi = [
+  {
+    type: "function",
+    name: "creditManager",
+    inputs: [],
+    outputs: [{ name: "", type: "address", internalType: "address" }],
+    stateMutability: "view"
+  }
+];
+const MAP_LABEL = "withdrawableAssets";
+class AbstractWithdrawalCompressorContract extends import_base.BaseContract {
+  #sdk;
+  #withdrawableAssets;
+  constructor(sdk, args) {
+    super(sdk, args);
+    this.#sdk = sdk;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.hydrate}
+   **/
+  hydrate(state) {
+    this.#withdrawableAssets = new import_utils.AddressMap(
+      Object.entries(state.withdrawableAssets),
+      MAP_LABEL
+    );
+  }
+  /**
+   * 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.state}
+   **/
+  get state() {
+    return this.#withdrawableAssets ? { withdrawableAssets: this.#withdrawableAssets.asRecord() } : void 0;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawableAssets}
+   **/
+  getWithdrawableAssets(...creditManagers) {
+    const cache = this.#withdrawableAssets;
+    if (!cache) {
+      throw new Error(
+        "withdrawable assets are not loaded, call loadWithdrawableAssets first"
+      );
+    }
+    if (creditManagers.length === 0) {
+      return cache.values().flat();
+    }
+    return creditManagers.flatMap((cm) => cache.get(cm) ?? []);
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.loadWithdrawableAssets}
+   **/
+  async loadWithdrawableAssets(force) {
+    if (this.#withdrawableAssets && !force) {
+      return this.getWithdrawableAssets();
+    }
+    const cms = 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
+    });
+    const cache = new import_utils.AddressMap(void 0, MAP_LABEL);
+    for (let i = 0; i < resp.length; i++) {
+      const r = resp[i];
+      if (r.status !== "success") {
+        this.logger?.warn(
+          `failed to get withdrawable assets of credit manager ${cms[i]}: ${r.error}`
+        );
+        continue;
+      }
+      if (r.result.length > 0) {
+        cache.upsert(
+          cms[i],
+          r.result.map((a) => toWithdrawableAsset(a, cms[i]))
+        );
+      }
+    }
+    this.#withdrawableAssets = cache;
+    return this.getWithdrawableAssets();
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssets}
+   **/
+  async findWithdrawableAssets(creditManager, token) {
+    await this.loadWithdrawableAssets();
+    return this.getWithdrawableAssets(creditManager).filter(
+      (a) => (0, import_viem.isAddressEqual)(a.token, token)
+    );
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.findWithdrawableAssetsByPhantomToken}
+   **/
+  async findWithdrawableAssetsByPhantomToken(withdrawalPhantomToken) {
+    await this.loadWithdrawableAssets();
+    return this.getWithdrawableAssets().filter(
+      (a) => (0, import_viem.isAddressEqual)(a.withdrawalPhantomToken, withdrawalPhantomToken)
+    );
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalPhantomToken}
+   **/
+  async getWithdrawalPhantomToken(creditManager, token) {
+    const [asset] = await this.findWithdrawableAssets(creditManager, token);
+    if (!asset) {
+      throw new Error(
+        `token ${token} is not withdrawable from credit manager ${creditManager}`
+      );
+    }
+    return asset.withdrawalPhantomToken;
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalSourceToken}
+   **/
+  getWithdrawalSourceToken(withdrawalPhantomToken) {
+    return this.getWithdrawableAssets().find(
+      (a) => (0, import_viem.isAddressEqual)(a.withdrawalPhantomToken, withdrawalPhantomToken)
+    )?.token;
+  }
+  /**
+   * {@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)),
+      pending: pending.map((w) => toPendingWithdrawal(w, creditManager)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+    };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+   **/
+  async getExternalAccountCurrentWithdrawals(_account, ..._withdrawalTokens) {
+    this.#reportUnsupported("external account withdrawals");
+    return { claimable: [], pending: [] };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+   **/
+  async getWithdrawalStatus(...redeemers) {
+    if (redeemers.length === 0) {
+      return [];
+    }
+    this.#reportUnsupported("withdrawal status");
+    return redeemers.map(() => "NULL");
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalRequestResult}
+   *
+   * Legacy compressors only support the 3-arg overload: `intent` and
+   * `withdrawalPhantomToken` are reported as unsupported (in non-strict mode
+   * the request is previewed without them).
+   **/
+  async getWithdrawalRequestResult({
+    creditAccount,
+    token,
+    amount,
+    withdrawalPhantomToken,
+    intent
+  }) {
+    if (intent) {
+      this.#reportUnsupported("withdrawal intents");
+    } else if (withdrawalPhantomToken) {
+      this.#reportUnsupported("withdrawal config selection");
+    }
+    const resp = await this.common.read.getWithdrawalRequestResult([
+      creditAccount,
+      token,
+      amount
+    ]);
+    return toRequestableWithdrawal(resp);
+  }
+  /**
+   * Reports that a feature is not supported by this compressor version:
+   * throws if `sdk.strictContractTypes` is `true`, otherwise logs a warning.
+   **/
+  #reportUnsupported(feature) {
+    const message = `${feature} is not supported by ${this.name} v${this.version}`;
+    if (this.#sdk.strictContractTypes) {
+      throw new Error(message);
+    }
+    this.logger?.warn(message);
+  }
+}
+function toWithdrawableAsset(a, creditManager) {
+  return { creditManager, ...a };
+}
+function toRequestableWithdrawal(resp) {
+  return {
+    token: resp.token,
+    amountIn: resp.amountIn,
+    outputs: [...resp.outputs],
+    requestCalls: [...resp.requestCalls],
+    claimableAt: resp.claimableAt
+  };
+}
+function toClaimableWithdrawal(w, creditManager) {
+  let intent;
+  if (creditManager && w.extraData && w.extraData !== "0x") {
+    intent = { ...(0, import_intent_codec.decodeDelayedIntent)(w.extraData), creditManager };
+  }
+  return {
+    token: w.token,
+    withdrawalPhantomToken: w.withdrawalPhantomToken,
+    withdrawalTokenSpent: w.withdrawalTokenSpent,
+    outputs: [...w.outputs],
+    claimCalls: [...w.claimCalls],
+    intent
+  };
+}
+function toPendingWithdrawal(w, creditManager) {
+  let intent;
+  if (creditManager && w.extraData && w.extraData !== "0x") {
+    intent = { ...(0, import_intent_codec.decodeDelayedIntent)(w.extraData), creditManager };
+  }
+  return {
+    token: w.token,
+    withdrawalPhantomToken: w.withdrawalPhantomToken,
+    expectedOutputs: [...w.expectedOutputs],
+    claimableAt: w.claimableAt,
+    intent
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractWithdrawalCompressorContract,
+  iCreditAccountAbi,
+  toClaimableWithdrawal,
+  toPendingWithdrawal,
+  toRequestableWithdrawal
+});

package/dist/cjs/sdk/accounts/withdrawal-compressor/RedemptionLoggerV310Contract.js

@@ -0,0 +1,72 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RedemptionLoggerV310Contract_exports = {};
+__export(RedemptionLoggerV310Contract_exports, {
+  RedemptionLoggerV310Contract: () => RedemptionLoggerV310Contract
+});
+module.exports = __toCommonJS(RedemptionLoggerV310Contract_exports);
+var import_iRedemptionLoggerV310 = require("../../../abi/iRedemptionLoggerV310.js");
+var import_base = require("../../base/index.js");
+var import_errors = require("./errors.js");
+var import_intent_codec = require("./intent-codec.js");
+const abi = import_iRedemptionLoggerV310.iRedemptionLoggerV310Abi;
+class RedemptionLoggerV310Contract extends import_base.BaseContract {
+  constructor(sdk, address, version) {
+    super(sdk, {
+      addr: address,
+      name: "RedemptionLogger",
+      abi,
+      version
+    });
+  }
+  /**
+   * Returns the redemption data logged for a redeemer; all-zero fields when
+   * nothing was logged for it.
+   **/
+  async getRedemptionLog(redeemer, blockNumber) {
+    return this.contract.read.redemptionLogs([redeemer], {
+      blockNumber
+    });
+  }
+  /**
+   * Reads the redemption log of a redeemer and decodes the recorded intent.
+   *
+   * @param redeemer - Redeemer contract the withdrawal is claimed from.
+   * @param blockNumber - Optional block number to read the log at.
+   * @returns The decoded intent, or `undefined` when the log carries none
+   * (including when nothing was logged for the redeemer).
+   * @throws InvalidDelayedIntentError when the logged `extraData` is
+   * non-empty but cannot be decoded as a `DelayedIntent`.
+   **/
+  async getDelayedIntent(redeemer, blockNumber) {
+    const log = await this.getRedemptionLog(redeemer, blockNumber);
+    if (!log.extraData || log.extraData === "0x") {
+      return void 0;
+    }
+    try {
+      return (0, import_intent_codec.decodeDelayedIntent)(log.extraData);
+    } catch (e) {
+      throw new import_errors.InvalidDelayedIntentError(log.extraData, e);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedemptionLoggerV310Contract
+});

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

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WithdrawalCompressorV310Contract_exports = {};
+__export(WithdrawalCompressorV310Contract_exports, {
+  WithdrawalCompressorV310Contract: () => WithdrawalCompressorV310Contract
+});
+module.exports = __toCommonJS(WithdrawalCompressorV310Contract_exports);
+var import_IWithdrawalCompressorV310 = require("../../../abi/IWithdrawalCompressorV310.js");
+var import_AbstractWithdrawalCompressorContract = require("./AbstractWithdrawalCompressorContract.js");
+const abi = import_IWithdrawalCompressorV310.iWithdrawalCompressorV310Abi;
+class WithdrawalCompressorV310Contract extends import_AbstractWithdrawalCompressorContract.AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV310",
+      abi,
+      version: 310
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WithdrawalCompressorV310Contract
+});

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

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WithdrawalCompressorV311Contract_exports = {};
+__export(WithdrawalCompressorV311Contract_exports, {
+  WithdrawalCompressorV311Contract: () => WithdrawalCompressorV311Contract
+});
+module.exports = __toCommonJS(WithdrawalCompressorV311Contract_exports);
+var import_IWithdrawalCompressorV311 = require("../../../abi/IWithdrawalCompressorV311.js");
+var import_AbstractWithdrawalCompressorContract = require("./AbstractWithdrawalCompressorContract.js");
+const abi = import_IWithdrawalCompressorV311.iWithdrawalCompressorV311Abi;
+class WithdrawalCompressorV311Contract extends import_AbstractWithdrawalCompressorContract.AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV311",
+      abi,
+      version: 311
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WithdrawalCompressorV311Contract
+});

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

@@ -0,0 +1,222 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WithdrawalCompressorV313Contract_exports = {};
+__export(WithdrawalCompressorV313Contract_exports, {
+  WithdrawalCompressorV313Contract: () => WithdrawalCompressorV313Contract
+});
+module.exports = __toCommonJS(WithdrawalCompressorV313Contract_exports);
+var import_IWithdrawalCompressorV313 = require("../../../abi/IWithdrawalCompressorV313.js");
+var import_AbstractWithdrawalCompressorContract = require("./AbstractWithdrawalCompressorContract.js");
+var import_intent_codec = require("./intent-codec.js");
+var import_types = require("./types.js");
+const abi = import_IWithdrawalCompressorV313.iWithdrawalCompressorV313Abi;
+const iExternalWithdrawalsBatchAbi = [
+  {
+    type: "function",
+    name: "getExternalAccountCurrentWithdrawals",
+    inputs: [
+      {
+        name: "withdrawalTokens",
+        type: "address[]",
+        internalType: "address[]"
+      },
+      { name: "account", type: "address", internalType: "address" }
+    ],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct ClaimableWithdrawal[]",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          {
+            name: "withdrawalPhantomToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "withdrawalTokenSpent",
+            type: "uint256",
+            internalType: "uint256"
+          },
+          {
+            name: "outputs",
+            type: "tuple[]",
+            internalType: "struct WithdrawalOutput[]",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "isDelayed", type: "bool", internalType: "bool" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          {
+            name: "claimCalls",
+            type: "tuple[]",
+            internalType: "struct MultiCall[]",
+            components: [
+              { name: "target", type: "address", internalType: "address" },
+              { name: "callData", type: "bytes", internalType: "bytes" }
+            ]
+          },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
+        ]
+      },
+      {
+        name: "",
+        type: "tuple[]",
+        internalType: "struct PendingWithdrawal[]",
+        components: [
+          { name: "token", type: "address", internalType: "address" },
+          {
+            name: "withdrawalPhantomToken",
+            type: "address",
+            internalType: "address"
+          },
+          {
+            name: "expectedOutputs",
+            type: "tuple[]",
+            internalType: "struct WithdrawalOutput[]",
+            components: [
+              { name: "token", type: "address", internalType: "address" },
+              { name: "isDelayed", type: "bool", internalType: "bool" },
+              { name: "amount", type: "uint256", internalType: "uint256" }
+            ]
+          },
+          { name: "claimableAt", type: "uint256", internalType: "uint256" },
+          { name: "extraData", type: "bytes", internalType: "bytes" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  }
+];
+const iWithdrawalStatusBatchAbi = [
+  {
+    type: "function",
+    name: "getWithdrawalStatus",
+    inputs: [
+      { name: "redeemers", type: "address[]", internalType: "address[]" }
+    ],
+    outputs: [
+      { name: "", type: "uint8[]", internalType: "enum WithdrawalStatus[]" }
+    ],
+    stateMutability: "view"
+  }
+];
+class WithdrawalCompressorV313Contract extends import_AbstractWithdrawalCompressorContract.AbstractWithdrawalCompressorContract {
+  constructor(sdk, address) {
+    super(sdk, {
+      addr: address,
+      name: "WithdrawalCompressorV313",
+      abi,
+      version: 313
+    });
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getExternalAccountCurrentWithdrawals}
+   **/
+  async getExternalAccountCurrentWithdrawals(account, ...withdrawalTokens) {
+    if (withdrawalTokens.length === 0) {
+      return { claimable: [], pending: [] };
+    }
+    const [claimable, pending] = await this.client.readContract({
+      address: this.address,
+      abi: iExternalWithdrawalsBatchAbi,
+      functionName: "getExternalAccountCurrentWithdrawals",
+      args: [withdrawalTokens, account]
+    });
+    return {
+      claimable: claimable.map((w) => (0, import_AbstractWithdrawalCompressorContract.toClaimableWithdrawal)(w, void 0)),
+      pending: pending.map((w) => (0, import_AbstractWithdrawalCompressorContract.toPendingWithdrawal)(w, void 0)).sort((a, b) => a.claimableAt < b.claimableAt ? -1 : 1)
+    };
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalStatus}
+   **/
+  async getWithdrawalStatus(...redeemers) {
+    if (redeemers.length === 0) {
+      return [];
+    }
+    const resp = await this.client.readContract({
+      address: this.address,
+      abi: iWithdrawalStatusBatchAbi,
+      functionName: "getWithdrawalStatus",
+      args: [redeemers]
+    });
+    return resp.map((s) => (0, import_types.toWithdrawalStatus)(s));
+  }
+  /**
+   * {@inheritDoc IWithdrawalCompressorContract.getWithdrawalRequestResult}
+   *
+   * When an intent is provided, it is abi-encoded and attached to the request
+   * as `extraData`. The contract overload accepting `extraData` also requires
+   * the withdrawal phantom token; when not provided by the caller, it is
+   * resolved the same way the 3-arg overload does it internally: via the
+   * withdrawable assets of the account's credit manager.
+   **/
+  async getWithdrawalRequestResult({
+    creditAccount,
+    token,
+    amount,
+    withdrawalPhantomToken,
+    intent
+  }) {
+    let resp;
+    if (intent) {
+      const extraData = (0, import_intent_codec.encodeDelayedIntent)(intent);
+      let phantomToken = withdrawalPhantomToken;
+      if (!phantomToken) {
+        const creditManager = await this.client.readContract({
+          address: creditAccount,
+          abi: import_AbstractWithdrawalCompressorContract.iCreditAccountAbi,
+          functionName: "creditManager"
+        });
+        phantomToken = await this.getWithdrawalPhantomToken(
+          creditManager,
+          token
+        );
+      }
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        phantomToken,
+        amount,
+        extraData
+      ]);
+    } else if (withdrawalPhantomToken) {
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        withdrawalPhantomToken,
+        amount
+      ]);
+    } else {
+      resp = await this.contract.read.getWithdrawalRequestResult([
+        creditAccount,
+        token,
+        amount
+      ]);
+    }
+    return (0, import_AbstractWithdrawalCompressorContract.toRequestableWithdrawal)(resp);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  WithdrawalCompressorV313Contract
+});