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

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

@@ -0,0 +1,78 @@
+"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 AllowancePrerequisite_exports = {};
+__export(AllowancePrerequisite_exports, {
+  AllowancePrerequisite: () => AllowancePrerequisite
+});
+module.exports = __toCommonJS(AllowancePrerequisite_exports);
+var import_viem = require("viem");
+var import_Prerequisite = require("./Prerequisite.js");
+class AllowancePrerequisite extends import_Prerequisite.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: import_viem.erc20Abi,
+        functionName: "allowance",
+        args: [this.#detail.owner, this.#detail.spender]
+      }
+    ];
+  }
+  resolve(slice) {
+    const res = slice[0];
+    if (!res || res.status === "failure") {
+      return this.errorResult((0, import_Prerequisite.toPrerequisiteError)(res?.error));
+    }
+    const actual = res.result;
+    return this.satisfiedResult(actual >= this.#detail.required, {
+      ...this.#detail,
+      actual
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AllowancePrerequisite
+});

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

@@ -0,0 +1,95 @@
+"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 BalancePrerequisite_exports = {};
+__export(BalancePrerequisite_exports, {
+  BalancePrerequisite: () => BalancePrerequisite
+});
+module.exports = __toCommonJS(BalancePrerequisite_exports);
+var import_viem = require("viem");
+var import_iMulticall3 = require("../../abi/iMulticall3.js");
+var import_sdk = require("../../sdk/index.js");
+var import_Prerequisite = require("./Prerequisite.js");
+class BalancePrerequisite extends import_Prerequisite.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 ((0, import_sdk.hexEq)(this.#detail.token, import_sdk.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: import_iMulticall3.iMulticall3Abi,
+          functionName: "getEthBalance",
+          args: [this.#detail.owner]
+        }
+      ];
+    }
+    return [
+      {
+        address: this.#detail.token,
+        abi: import_viem.erc20Abi,
+        functionName: "balanceOf",
+        args: [this.#detail.owner]
+      }
+    ];
+  }
+  resolve(slice) {
+    const res = slice[0];
+    if (!res || res.status === "failure") {
+      return this.errorResult((0, import_Prerequisite.toPrerequisiteError)(res?.error));
+    }
+    const actual = res.result;
+    return this.satisfiedResult(actual >= this.#detail.required, {
+      ...this.#detail,
+      actual
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BalancePrerequisite
+});

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

@@ -0,0 +1,85 @@
+"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 Prerequisite_exports = {};
+__export(Prerequisite_exports, {
+  Prerequisite: () => Prerequisite,
+  toPrerequisiteError: () => toPrerequisiteError
+});
+module.exports = __toCommonJS(Prerequisite_exports);
+var import_viem = require("viem");
+function toPrerequisiteError(cause) {
+  if (cause instanceof import_viem.BaseError) {
+    const reverted = cause.walk(
+      (e) => e instanceof import_viem.ContractFunctionRevertedError
+    );
+    if (reverted instanceof import_viem.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
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Prerequisite,
+  toPrerequisiteError
+});

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

@@ -0,0 +1,66 @@
+"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 RWAOpenRequirementsPrerequisite_exports = {};
+__export(RWAOpenRequirementsPrerequisite_exports, {
+  RWAOpenRequirementsPrerequisite: () => RWAOpenRequirementsPrerequisite
+});
+module.exports = __toCommonJS(RWAOpenRequirementsPrerequisite_exports);
+var import_Prerequisite = require("./Prerequisite.js");
+class RWAOpenRequirementsPrerequisite extends import_Prerequisite.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;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RWAOpenRequirementsPrerequisite
+});

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

@@ -0,0 +1,297 @@
+"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 buildPrerequisites_exports = {};
+__export(buildPrerequisites_exports, {
+  buildPrerequisites: () => buildPrerequisites
+});
+module.exports = __toCommonJS(buildPrerequisites_exports);
+var import_viem = require("viem");
+var import_sdk = require("../../sdk/index.js");
+var import_parseOperationCalldata = require("../parse/parseOperationCalldata.js");
+var import_AllowancePrerequisite = require("./AllowancePrerequisite.js");
+var import_BalancePrerequisite = require("./BalancePrerequisite.js");
+var import_RWAOpenRequirementsPrerequisite = require("./RWAOpenRequirementsPrerequisite.js");
+async function buildPrerequisites(input) {
+  const { sdk, sender: wallet, blockNumber } = input;
+  const tx = (0, import_parseOperationCalldata.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 (!(0, import_viem.isAddressEqual)(tx.tokenIn, import_sdk.NATIVE_ADDRESS)) {
+          prereqs.push(
+            new import_AllowancePrerequisite.AllowancePrerequisite({
+              token: tx.tokenIn,
+              owner: wallet,
+              spender: tx.zapper,
+              required: tx.assets,
+              title: "Token approved to zapper"
+            })
+          );
+        }
+        prereqs.push(
+          new import_BalancePrerequisite.BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.assets,
+            title: "Sufficient token balance"
+          })
+        );
+        return prereqs;
+      }
+      return [
+        new import_AllowancePrerequisite.AllowancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          spender: tx.pool,
+          required: tx.assets,
+          title: "Token approved to pool"
+        }),
+        new import_BalancePrerequisite.BalancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          required: tx.assets,
+          title: "Sufficient token balance"
+        })
+      ];
+    case "Mint":
+      return [
+        new import_AllowancePrerequisite.AllowancePrerequisite({
+          token: tx.underlying,
+          owner: wallet,
+          spender: tx.pool,
+          required: tx.shares,
+          title: "Token approved to pool"
+        }),
+        new import_BalancePrerequisite.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 import_BalancePrerequisite.BalancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            required: tx.shares,
+            title: "Sufficient share token balance"
+          }),
+          new import_AllowancePrerequisite.AllowancePrerequisite({
+            token: tx.tokenIn,
+            owner: wallet,
+            spender: tx.zapper,
+            required: tx.shares,
+            title: "Share token approved to zapper"
+          })
+        ];
+      }
+      const prereqs = [
+        new import_BalancePrerequisite.BalancePrerequisite({
+          token: tx.pool,
+          owner: tx.owner,
+          required: tx.shares,
+          title: "Sufficient LP token balance"
+        })
+      ];
+      if (!(0, import_viem.isAddressEqual)(tx.owner, wallet)) {
+        prereqs.push(
+          new import_AllowancePrerequisite.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 import_BalancePrerequisite.BalancePrerequisite({
+          token: tx.pool,
+          owner: tx.owner,
+          required: tx.assets,
+          title: "Sufficient LP token balance"
+        })
+      ];
+      if (!(0, import_viem.isAddressEqual)(tx.owner, wallet)) {
+        prereqs.push(
+          new import_AllowancePrerequisite.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 import_AllowancePrerequisite.AllowancePrerequisite({
+          token: underlying,
+          owner: wallet,
+          spender: tx.creditManager,
+          required: tx.repaidAmount,
+          title: "Underlying approved to credit manager"
+        }),
+        new import_BalancePrerequisite.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 import_sdk.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 import_AllowancePrerequisite.AllowancePrerequisite({
+        token,
+        owner: wallet,
+        spender,
+        required: amount,
+        title: "Collateral approved"
+      }),
+      new import_BalancePrerequisite.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 import_sdk.AddressSet(rwaFactory.getTokens());
+  const candidates = new import_sdk.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 import_RWAOpenRequirementsPrerequisite.RWAOpenRequirementsPrerequisite({
+          requirements,
+          token,
+          factory: rwaFactory.address
+        })
+      );
+    }
+  }
+  return prereqs;
+}
+function underlyingOf(sdk, creditManager) {
+  const suite = sdk.marketRegister.creditManagers.find(
+    (cm) => (0, import_viem.isAddressEqual)(cm.creditManager.address, creditManager)
+  );
+  return suite?.underlying;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildPrerequisites
+});

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

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prerequisites_exports = {};
+module.exports = __toCommonJS(prerequisites_exports);
+__reExport(prerequisites_exports, require("./AllowancePrerequisite.js"), module.exports);
+__reExport(prerequisites_exports, require("./BalancePrerequisite.js"), module.exports);
+__reExport(prerequisites_exports, require("./buildPrerequisites.js"), module.exports);
+__reExport(prerequisites_exports, require("./Prerequisite.js"), module.exports);
+__reExport(prerequisites_exports, require("./prepareAction.js"), module.exports);
+__reExport(prerequisites_exports, require("./RWAOpenRequirementsPrerequisite.js"), module.exports);
+__reExport(prerequisites_exports, require("./runPrerequisites.js"), module.exports);
+__reExport(prerequisites_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./AllowancePrerequisite.js"),
+  ...require("./BalancePrerequisite.js"),
+  ...require("./buildPrerequisites.js"),
+  ...require("./Prerequisite.js"),
+  ...require("./prepareAction.js"),
+  ...require("./RWAOpenRequirementsPrerequisite.js"),
+  ...require("./runPrerequisites.js"),
+  ...require("./types.js")
+});