@gearbox-protocol/sdk 14.12.0-next.16 → 14.12.0-next.18

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

@@ -0,0 +1,205 @@
+import { isAddressEqual } from "viem";
+import { BaseContract } from "../../base/index.js";
+import { decodeDelayedIntent, encodeDelayedIntent } from "./intent.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) {
+    if (!w.extraData || w.extraData === "0x") {
+      throw new Error(
+        `claimable withdrawal of ${w.token} has no delayed intent in extraData`
+      );
+    }
+    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.js";
+export * from "./types.js";
+export * from "./WithdrawalCompressorV310Contract.js";
+export * from "./WithdrawalCompressorV311Contract.js";
+export * from "./WithdrawalCompressorV313Contract.js";

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

@@ -0,0 +1,137 @@
+import { decodeAbiParameters, encodeAbiParameters } from "viem";
+import { z } from "zod/v4";
+import { ZodAddress } from "../../utils/index.js";
+const delayedIncreaseLeverageIntentSchema = z.object({
+  type: z.literal("INCREASE_LEVERAGE"),
+  to: ZodAddress()
+});
+const delayedDepositIntentSchema = z.object({
+  type: z.literal("DEPOSIT")
+});
+const delayedDepositAndIncreaseLeverageIntentSchema = z.object({
+  type: z.literal("DEPOSIT_AND_INCREASE_LEVERAGE")
+});
+const delayedWithdrawCollateralIntentSchema = z.object({
+  type: z.literal("WITHDRAW_COLLATERAL"),
+  to: ZodAddress(),
+  withdrawToken: ZodAddress(),
+  withdrawAmount: z.bigint()
+});
+const delayedCloseAccountIntentSchema = z.object({
+  type: z.literal("CLOSE_ACCOUNT"),
+  to: ZodAddress()
+});
+const delayedAddCollateralIntentSchema = z.object({
+  type: z.literal("ADD_COLLATERAL")
+});
+const delayedDecreaseLeverageIntentSchema = z.object({
+  type: z.literal("DECREASE_LEVERAGE")
+});
+const delayedIntentSchema = z.discriminatedUnion("type", [
+  delayedIncreaseLeverageIntentSchema,
+  delayedDepositIntentSchema,
+  delayedDepositAndIncreaseLeverageIntentSchema,
+  delayedWithdrawCollateralIntentSchema,
+  delayedCloseAccountIntentSchema,
+  delayedAddCollateralIntentSchema,
+  delayedDecreaseLeverageIntentSchema
+]);
+const DELAYED_INTENT_VERSION = 1;
+const DELAYED_INTENT_TYPES = {
+  INCREASE_LEVERAGE: 1,
+  DEPOSIT: 2,
+  DEPOSIT_AND_INCREASE_LEVERAGE: 3,
+  WITHDRAW_COLLATERAL: 4,
+  CLOSE_ACCOUNT: 5,
+  ADD_COLLATERAL: 6,
+  DECREASE_LEVERAGE: 7
+};
+const HEADER_PARAMS = [
+  { type: "uint8", name: "version" },
+  { type: "uint8", name: "intentType" }
+];
+const TO_PARAMS = [...HEADER_PARAMS, { type: "address", name: "to" }];
+const WITHDRAW_COLLATERAL_PARAMS = [
+  ...TO_PARAMS,
+  { type: "address", name: "withdrawToken" },
+  { type: "uint256", name: "withdrawAmount" }
+];
+function encodeDelayedIntent(intent) {
+  const parsed = delayedIntentSchema.parse(intent);
+  const version = DELAYED_INTENT_VERSION;
+  const intentType = DELAYED_INTENT_TYPES[parsed.type];
+  switch (parsed.type) {
+    case "INCREASE_LEVERAGE":
+    case "CLOSE_ACCOUNT":
+      return encodeAbiParameters(TO_PARAMS, [version, intentType, parsed.to]);
+    case "WITHDRAW_COLLATERAL":
+      return encodeAbiParameters(WITHDRAW_COLLATERAL_PARAMS, [
+        version,
+        intentType,
+        parsed.to,
+        parsed.withdrawToken,
+        parsed.withdrawAmount
+      ]);
+    case "DEPOSIT":
+    case "DEPOSIT_AND_INCREASE_LEVERAGE":
+    case "ADD_COLLATERAL":
+    case "DECREASE_LEVERAGE":
+      return encodeAbiParameters(HEADER_PARAMS, [version, intentType]);
+    default: {
+      const t = parsed;
+      throw new Error(`unknown delayed intent: ${JSON.stringify(t)}`);
+    }
+  }
+}
+function decodeDelayedIntent(data) {
+  const [version, intentType] = decodeAbiParameters(HEADER_PARAMS, data);
+  if (version !== DELAYED_INTENT_VERSION) {
+    throw new Error(`unsupported delayed intent version: ${version}`);
+  }
+  switch (intentType) {
+    case DELAYED_INTENT_TYPES.INCREASE_LEVERAGE: {
+      const [, , to] = decodeAbiParameters(TO_PARAMS, data);
+      return delayedIntentSchema.parse({ type: "INCREASE_LEVERAGE", to });
+    }
+    case DELAYED_INTENT_TYPES.DEPOSIT:
+      return { type: "DEPOSIT" };
+    case DELAYED_INTENT_TYPES.DEPOSIT_AND_INCREASE_LEVERAGE:
+      return { type: "DEPOSIT_AND_INCREASE_LEVERAGE" };
+    case DELAYED_INTENT_TYPES.WITHDRAW_COLLATERAL: {
+      const [, , to, withdrawToken, withdrawAmount] = decodeAbiParameters(
+        WITHDRAW_COLLATERAL_PARAMS,
+        data
+      );
+      return delayedIntentSchema.parse({
+        type: "WITHDRAW_COLLATERAL",
+        to,
+        withdrawToken,
+        withdrawAmount
+      });
+    }
+    case DELAYED_INTENT_TYPES.CLOSE_ACCOUNT: {
+      const [, , to] = decodeAbiParameters(TO_PARAMS, data);
+      return delayedIntentSchema.parse({ type: "CLOSE_ACCOUNT", to });
+    }
+    case DELAYED_INTENT_TYPES.ADD_COLLATERAL:
+      return { type: "ADD_COLLATERAL" };
+    case DELAYED_INTENT_TYPES.DECREASE_LEVERAGE:
+      return { type: "DECREASE_LEVERAGE" };
+    default:
+      throw new Error(`unknown delayed intent type: ${intentType}`);
+  }
+}
+export {
+  DELAYED_INTENT_TYPES,
+  DELAYED_INTENT_VERSION,
+  decodeDelayedIntent,
+  delayedAddCollateralIntentSchema,
+  delayedCloseAccountIntentSchema,
+  delayedDecreaseLeverageIntentSchema,
+  delayedDepositAndIncreaseLeverageIntentSchema,
+  delayedDepositIntentSchema,
+  delayedIncreaseLeverageIntentSchema,
+  delayedIntentSchema,
+  delayedWithdrawCollateralIntentSchema,
+  encodeDelayedIntent
+};

package/dist/types/abi/{IWithdrawalCompressorV312.d.ts → IWithdrawalCompressorV313.d.ts}

@@ -1,4 +1,4 @@
-export declare const iWithdrawalCompressorV312Abi: readonly [{
+export declare const iWithdrawalCompressorV313Abi: readonly [{
     readonly type: "function";
     readonly name: "contractType";
     readonly inputs: readonly [];
@@ -138,6 +138,79 @@ export declare const iWithdrawalCompressorV312Abi: readonly [{
         }];
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWithdrawalRequestResult";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "withdrawalToken";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "extraData";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "tuple";
+        readonly internalType: "struct RequestableWithdrawal";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "amountIn";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "requestCalls";
+            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 name: "claimableAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "getWithdrawalRequestResult";

package/dist/types/abi/compressors/subcompressors/withdrawal/mellowWithdrawalSubcompressor.d.ts

@@ -66,6 +66,10 @@ export declare const mellowWithdrawalSubcompressorAbi: readonly [{
                 readonly type: "bytes";
                 readonly internalType: "bytes";
             }];
+        }, {
+            readonly name: "extraData";
+            readonly type: "bytes";
+            readonly internalType: "bytes";
         }];
     }, {
         readonly name: "";
@@ -142,6 +146,79 @@ export declare const mellowWithdrawalSubcompressorAbi: readonly [{
         }];
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getWithdrawalRequestResult";
+    readonly inputs: readonly [{
+        readonly name: "creditAccount";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "withdrawalToken";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "";
+        readonly type: "bytes";
+        readonly internalType: "bytes";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "requestableWithdrawal";
+        readonly type: "tuple";
+        readonly internalType: "struct RequestableWithdrawal";
+        readonly components: readonly [{
+            readonly name: "token";
+            readonly type: "address";
+            readonly internalType: "address";
+        }, {
+            readonly name: "amountIn";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }, {
+            readonly name: "outputs";
+            readonly type: "tuple[]";
+            readonly internalType: "struct WithdrawalOutput[]";
+            readonly components: readonly [{
+                readonly name: "token";
+                readonly type: "address";
+                readonly internalType: "address";
+            }, {
+                readonly name: "isDelayed";
+                readonly type: "bool";
+                readonly internalType: "bool";
+            }, {
+                readonly name: "amount";
+                readonly type: "uint256";
+                readonly internalType: "uint256";
+            }];
+        }, {
+            readonly name: "requestCalls";
+            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 name: "claimableAt";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "getWithdrawalRequestResult";