@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.10

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

@@ -0,0 +1,65 @@
+import { UnsupportedPoolFunctionError } from "./errors.js";
+function parsePoolOperationCalldata(props) {
+  const { sdk, pool, calldata } = props;
+  const parsed = sdk.parseFunctionDataV2(pool.address, calldata);
+  const functionName = parsed.functionName.split("(")[0];
+  const { rawArgs } = parsed;
+  const underlying = pool.underlying;
+  switch (functionName) {
+    case "deposit":
+    case "depositWithReferral":
+      return {
+        operation: "Deposit",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        assets: rawArgs.assets,
+        underlying,
+        tokenIn: underlying,
+        tokenOut: pool.address,
+        zapper: void 0,
+        referralCode: functionName === "depositWithReferral" ? rawArgs.referralCode : void 0
+      };
+    case "mint":
+    case "mintWithReferral":
+      return {
+        operation: "Mint",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        shares: rawArgs.shares,
+        underlying,
+        tokenIn: underlying,
+        tokenOut: pool.address,
+        zapper: void 0,
+        referralCode: functionName === "mintWithReferral" ? rawArgs.referralCode : void 0
+      };
+    case "withdraw":
+      return {
+        operation: "Withdraw",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        owner: rawArgs.owner,
+        assets: rawArgs.assets,
+        underlying,
+        tokenIn: pool.address,
+        tokenOut: underlying,
+        zapper: void 0
+      };
+    case "redeem":
+      return {
+        operation: "Redeem",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        owner: rawArgs.owner,
+        shares: rawArgs.shares,
+        underlying,
+        tokenIn: pool.address,
+        tokenOut: underlying,
+        zapper: void 0
+      };
+    default:
+      throw new UnsupportedPoolFunctionError(pool.address, parsed.functionName);
+  }
+}
+export {
+  parsePoolOperationCalldata
+};

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
+};

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

@@ -0,0 +1,14 @@
+export * from "./types-adapters.js";
+export * from "./types-facades.js";
+export * from "./types-pools.js";
+export * from "./types-rwa.js";
+function isPoolOperation(tx) {
+  return tx.operation === "Deposit" || tx.operation === "Mint" || tx.operation === "Withdraw" || tx.operation === "Redeem";
+}
+function isRWAOperation(tx) {
+  return tx.operation === "SecuritizeOpenCreditAccount" || tx.operation === "SecuritizeMulticall";
+}
+export {
+  isPoolOperation,
+  isRWAOperation
+};

package/dist/esm/preview/prerequisites/AllowancePrerequisite.js

@@ -0,0 +1,57 @@
+import { erc20Abi } from "viem";
+import {
+  Prerequisite,
+  toPrerequisiteError
+} from "./Prerequisite.js";
+class AllowancePrerequisite extends Prerequisite {
+  #id;
+  #title;
+  #detail;
+  constructor(props) {
+    super();
+    this.#id = props.id ?? `allowance:${props.token}:${props.owner}:${props.spender}`;
+    this.#title = props.title ?? "Token approval";
+    this.#detail = {
+      token: props.token,
+      owner: props.owner,
+      spender: props.spender,
+      required: props.required
+    };
+  }
+  get id() {
+    return this.#id;
+  }
+  get kind() {
+    return "allowance";
+  }
+  get title() {
+    return this.#title;
+  }
+  get detail() {
+    return this.#detail;
+  }
+  calls() {
+    return [
+      {
+        address: this.#detail.token,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [this.#detail.owner, this.#detail.spender]
+      }
+    ];
+  }
+  resolve(slice) {
+    const res = slice[0];
+    if (!res || res.status === "failure") {
+      return this.errorResult(toPrerequisiteError(res?.error));
+    }
+    const actual = res.result;
+    return this.satisfiedResult(actual >= this.#detail.required, {
+      ...this.#detail,
+      actual
+    });
+  }
+}
+export {
+  AllowancePrerequisite
+};

package/dist/esm/preview/prerequisites/BalancePrerequisite.js

@@ -0,0 +1,74 @@
+import { erc20Abi } from "viem";
+import { iMulticall3Abi } from "../../abi/iMulticall3.js";
+import { hexEq, NATIVE_ADDRESS } from "../../sdk/index.js";
+import {
+  Prerequisite,
+  toPrerequisiteError
+} from "./Prerequisite.js";
+class BalancePrerequisite extends Prerequisite {
+  #id;
+  #title;
+  #detail;
+  constructor(props) {
+    super();
+    this.#id = props.id ?? `balance:${props.token}:${props.owner}`;
+    this.#title = props.title ?? "Sufficient balance";
+    this.#detail = {
+      token: props.token,
+      owner: props.owner,
+      required: props.required
+    };
+  }
+  get id() {
+    return this.#id;
+  }
+  get kind() {
+    return "balance";
+  }
+  get title() {
+    return this.#title;
+  }
+  get detail() {
+    return this.#detail;
+  }
+  calls(ctx) {
+    if (hexEq(this.#detail.token, NATIVE_ADDRESS)) {
+      const multicall3 = ctx.sdk.client.chain.contracts?.multicall3?.address;
+      if (!multicall3) {
+        throw new Error(
+          "multicall3 is not configured for this chain, cannot read native balance"
+        );
+      }
+      return [
+        {
+          address: multicall3,
+          abi: iMulticall3Abi,
+          functionName: "getEthBalance",
+          args: [this.#detail.owner]
+        }
+      ];
+    }
+    return [
+      {
+        address: this.#detail.token,
+        abi: erc20Abi,
+        functionName: "balanceOf",
+        args: [this.#detail.owner]
+      }
+    ];
+  }
+  resolve(slice) {
+    const res = slice[0];
+    if (!res || res.status === "failure") {
+      return this.errorResult(toPrerequisiteError(res?.error));
+    }
+    const actual = res.result;
+    return this.satisfiedResult(actual >= this.#detail.required, {
+      ...this.#detail,
+      actual
+    });
+  }
+}
+export {
+  BalancePrerequisite
+};

package/dist/esm/preview/prerequisites/Prerequisite.js

@@ -0,0 +1,63 @@
+import {
+  BaseError,
+  ContractFunctionRevertedError
+} from "viem";
+function toPrerequisiteError(cause) {
+  if (cause instanceof BaseError) {
+    const reverted = cause.walk(
+      (e) => e instanceof ContractFunctionRevertedError
+    );
+    if (reverted instanceof ContractFunctionRevertedError) {
+      return {
+        reason: reverted.data?.errorName ?? reverted.shortMessage ?? "reverted",
+        cause
+      };
+    }
+    return { reason: cause.shortMessage ?? cause.name, cause };
+  }
+  if (cause instanceof Error) {
+    return { reason: cause.message, cause };
+  }
+  return { reason: "unknown error", cause };
+}
+class Prerequisite {
+  /**
+   * Verifies this prerequisite on its own using an `allowFailure` multicall.
+   * Prefer `verifyPrerequisites` to batch several checks into one round-trip.
+   */
+  async verify(ctx) {
+    const calls = this.calls(ctx);
+    const results = await ctx.sdk.client.multicall({
+      allowFailure: true,
+      contracts: calls,
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber: ctx.blockNumber
+    });
+    return this.resolve(results);
+  }
+  /** Builds a successful result; `detail` carries the on-chain `actual`. */
+  satisfiedResult(satisfied, detail) {
+    return {
+      id: this.id,
+      kind: this.kind,
+      title: this.title,
+      detail,
+      satisfied
+    };
+  }
+  /** Builds a failed result from a decoded read error. */
+  errorResult(error) {
+    return {
+      id: this.id,
+      kind: this.kind,
+      title: this.title,
+      detail: this.detail,
+      error
+    };
+  }
+}
+export {
+  Prerequisite,
+  toPrerequisiteError
+};

package/dist/esm/preview/prerequisites/RWAOpenRequirementsPrerequisite.js

@@ -0,0 +1,42 @@
+import { Prerequisite } from "./Prerequisite.js";
+class RWAOpenRequirementsPrerequisite extends Prerequisite {
+  #id;
+  #title;
+  #detail;
+  constructor(props) {
+    super();
+    this.#id = props.id ?? `rwaOpenRequirements:${props.factory}:${props.token}`;
+    this.#title = props.title ?? "RWA account requirements fulfilled";
+    this.#detail = props.requirements;
+  }
+  get id() {
+    return this.#id;
+  }
+  get kind() {
+    return "rwaOpenRequirements";
+  }
+  get title() {
+    return this.#title;
+  }
+  get detail() {
+    return this.#detail;
+  }
+  /** Pre-resolved: no on-chain reads to contribute. */
+  calls() {
+    return [];
+  }
+  resolve() {
+    return this.satisfiedResult(this.#satisfied(), this.#detail);
+  }
+  /**
+   * Satisfied when the borrower has nothing left to do: no tokens pending
+   * issuer-side registration and no messages left to sign.
+   */
+  #satisfied() {
+    const { securitizeTokensToRegister, requiredSignatures } = this.#detail;
+    return securitizeTokensToRegister.length === 0 && requiredSignatures.length === 0;
+  }
+}
+export {
+  RWAOpenRequirementsPrerequisite
+};

package/dist/esm/preview/prerequisites/buildPrerequisites.js

@@ -0,0 +1,279 @@
+import { isAddressEqual } from "viem";
+import {
+  AddressSet,
+  AssetsMap,
+  NATIVE_ADDRESS
+} from "../../sdk/index.js";
+import {
+  parseOperationCalldata
+} from "../parse/parseOperationCalldata.js";
+import { AllowancePrerequisite } from "./AllowancePrerequisite.js";
+import { BalancePrerequisite } from "./BalancePrerequisite.js";
+import { RWAOpenRequirementsPrerequisite } from "./RWAOpenRequirementsPrerequisite.js";
+async function buildPrerequisites(input) {
+  const { sdk, sender: wallet, blockNumber } = input;
+  const tx = parseOperationCalldata(input);
+  const ctx = { sdk, wallet, blockNumber };
+  switch (tx.operation) {
+    // Deposit and Mint both pull the underlying from the caller into the pool;
+    // they only differ in which side (assets vs shares) the caller specifies.
+    // The exact underlying amount for Mint is resolved by the pool, so we can
+    // only require an allowance/balance against the known specified amount —
+    // here we approximate Mint by its shares amount (a lower bound on assets is
+    // not knowable from calldata alone).
+    case "Deposit":
+      if (tx.zapper) {
+        const prereqs = [];
+        if (!isAddressEqual(tx.tokenIn, NATIVE_ADDRESS)) {
+          prereqs.push(
+            new AllowancePrerequisite({
+              token: tx.tokenIn,
+              owner: wallet,
+              spender: tx.zapper,
+              required: tx.assets,
+              title: "Token approved to zapper"
+            })
+          );
+        }
+        prereqs.push(
+          new BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.assets,
+            title: "Sufficient token balance"
+          })
+        );
+        return prereqs;
+      }
+      return [
+        new AllowancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          spender: tx.pool,
+          required: tx.assets,
+          title: "Token approved to pool"
+        }),
+        new BalancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          required: tx.assets,
+          title: "Sufficient token balance"
+        })
+      ];
+    case "Mint":
+      return [
+        new AllowancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          spender: tx.pool,
+          required: tx.shares,
+          title: "Token approved to pool"
+        }),
+        new BalancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          required: tx.shares,
+          title: "Sufficient token balance"
+        })
+      ];
+    // Redeem and Withdraw both burn LP shares from `owner`; they only differ in
+    // which side (shares vs assets) the caller specifies.
+    case "Redeem": {
+      if (tx.zapper) {
+        return [
+          new BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.shares,
+            title: "Sufficient share token balance"
+          }),
+          new AllowancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            spender: tx.zapper,
+            required: tx.shares,
+            title: "Share token approved to zapper"
+          })
+        ];
+      }
+      const prereqs = [
+        new BalancePrerequisite({
+          token: tx.pool,
+          owner: tx.owner,
+          required: tx.shares,
+          title: "Sufficient LP token balance"
+        })
+      ];
+      if (!isAddressEqual(tx.owner, wallet)) {
+        prereqs.push(
+          new AllowancePrerequisite({
+            token: tx.pool,
+            owner: tx.owner,
+            spender: wallet,
+            required: tx.shares,
+            title: "LP token approved to caller"
+          })
+        );
+      }
+      return prereqs;
+    }
+    case "Withdraw": {
+      const prereqs = [
+        new BalancePrerequisite({
+          token: tx.pool,
+          owner: tx.owner,
+          required: tx.assets,
+          title: "Sufficient LP token balance"
+        })
+      ];
+      if (!isAddressEqual(tx.owner, wallet)) {
+        prereqs.push(
+          new AllowancePrerequisite({
+            token: tx.pool,
+            owner: tx.owner,
+            spender: wallet,
+            required: tx.assets,
+            title: "LP token approved to caller"
+          })
+        );
+      }
+      return prereqs;
+    }
+    case "MultiCall":
+    case "BotMulticall":
+    case "OpenCreditAccount":
+    case "CloseCreditAccount":
+    case "LiquidateCreditAccount":
+      return collateralPrerequisites(
+        tx.operation === "OpenCreditAccount" ? { creditManager: tx.creditManager, borrower: wallet } : {
+          creditManager: tx.creditManager,
+          creditAccount: tx.creditAccount
+        },
+        tx.multicall,
+        ctx
+      );
+    // RWA-factory operations: same collateral checks as facade operations,
+    // plus (for opening) the factory's open-account requirements. The parsed
+    // operation carries template (empty) `tokensToRegister`/`signaturesToCache`;
+    // the prerequisite detail provides the real values.
+    case "SecuritizeOpenCreditAccount":
+      return [
+        ...await collateralPrerequisites(
+          { creditManager: tx.creditManager, borrower: wallet },
+          tx.multicall,
+          ctx
+        ),
+        ...await rwaOpenRequirementsPrerequisites(
+          tx.multicall,
+          tx.creditManager,
+          ctx
+        )
+      ];
+    case "SecuritizeMulticall":
+      return collateralPrerequisites(
+        { creditManager: tx.creditManager, creditAccount: tx.creditAccount },
+        tx.multicall,
+        ctx
+      );
+    case "PartiallyLiquidateCreditAccount": {
+      const underlying = underlyingOf(ctx.sdk, tx.creditManager);
+      if (!underlying || tx.repaidAmount === 0n) {
+        return [];
+      }
+      return [
+        new AllowancePrerequisite({
+          token: underlying,
+          owner: wallet,
+          spender: tx.creditManager,
+          required: tx.repaidAmount,
+          title: "Underlying approved to credit manager"
+        }),
+        new BalancePrerequisite({
+          token: underlying,
+          owner: wallet,
+          required: tx.repaidAmount,
+          title: "Sufficient underlying balance"
+        })
+      ];
+    }
+    default:
+      return [];
+  }
+}
+async function collateralPrerequisites(spenderOptions, multicall, ctx) {
+  const { sdk, wallet } = ctx;
+  const required = new AssetsMap();
+  for (const op of multicall) {
+    if (op.operation !== "AddCollateral" || op.amount === 0n) {
+      continue;
+    }
+    required.inc(op.token, op.amount);
+  }
+  if (required.size === 0) {
+    return [];
+  }
+  const spender = await sdk.accounts.getApprovalAddress(spenderOptions);
+  const prereqs = [];
+  for (const [token, amount] of required.entries()) {
+    prereqs.push(
+      new AllowancePrerequisite({
+        token,
+        owner: wallet,
+        spender,
+        required: amount,
+        title: "Collateral approved"
+      }),
+      new BalancePrerequisite({
+        token,
+        owner: wallet,
+        required: amount,
+        title: "Sufficient collateral balance"
+      })
+    );
+  }
+  return prereqs;
+}
+async function rwaOpenRequirementsPrerequisites(multicall, creditManager, ctx) {
+  const { sdk, wallet } = ctx;
+  const { rwaFactory } = sdk.marketRegister.findByCreditManager(creditManager);
+  if (!rwaFactory) {
+    return [];
+  }
+  const rwaTokens = new AddressSet(rwaFactory.getTokens());
+  const candidates = new AddressSet();
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral" || op.operation === "UpdateQuota") {
+      candidates.add(op.token);
+    }
+  }
+  const prereqs = [];
+  for (const token of candidates) {
+    if (!rwaTokens.has(token)) {
+      continue;
+    }
+    const requirements = await sdk.accounts.getOpenAccountRequirements(
+      wallet,
+      creditManager,
+      { tokenOutAddress: token }
+    );
+    if (requirements) {
+      prereqs.push(
+        new RWAOpenRequirementsPrerequisite({
+          requirements,
+          token,
+          factory: rwaFactory.address
+        })
+      );
+    }
+  }
+  return prereqs;
+}
+function underlyingOf(sdk, creditManager) {
+  const suite = sdk.marketRegister.creditManagers.find(
+    (cm) => isAddressEqual(cm.creditManager.address, creditManager)
+  );
+  return suite?.underlying;
+}
+export {
+  buildPrerequisites
+};

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

@@ -0,0 +1,8 @@
+export * from "./AllowancePrerequisite.js";
+export * from "./BalancePrerequisite.js";
+export * from "./buildPrerequisites.js";
+export * from "./Prerequisite.js";
+export * from "./prepareAction.js";
+export * from "./RWAOpenRequirementsPrerequisite.js";
+export * from "./runPrerequisites.js";
+export * from "./types.js";