@gearbox-protocol/sdk 14.12.0-next.12 → 14.12.0-next.14

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

@@ -1,297 +0,0 @@
-"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/runPrerequisites.js

@@ -1,71 +0,0 @@
-"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 runPrerequisites_exports = {};
-__export(runPrerequisites_exports, {
-  verifyPrerequisites: () => verifyPrerequisites
-});
-module.exports = __toCommonJS(runPrerequisites_exports);
-async function verifyPrerequisites(prereqs, ctx) {
-  if (prereqs.length === 0) {
-    return [];
-  }
-  const ranges = [];
-  const calls = [];
-  for (const prereq of prereqs) {
-    const start = calls.length;
-    calls.push(...prereq.calls(ctx));
-    ranges.push({ start, end: calls.length });
-  }
-  let results;
-  try {
-    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
-    });
-  } catch (cause) {
-    const error = cause instanceof Error ? cause : new Error(String(cause));
-    return prereqs.map(
-      (prereq, i) => (
-        // Each prereq pairs its own kind with its detail, so the widened
-        // `resolve` return is safe to narrow back to the discriminated union.
-        prereq.resolve(
-          failureSlice(ranges[i].end - ranges[i].start, error)
-        )
-      )
-    );
-  }
-  return prereqs.map(
-    (prereq, i) => prereq.resolve(
-      results.slice(ranges[i].start, ranges[i].end)
-    )
-  );
-}
-function failureSlice(n, error) {
-  return Array.from({ length: n }, () => ({
-    status: "failure",
-    error
-  }));
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  verifyPrerequisites
-});

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

@@ -1,279 +0,0 @@
-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/prepareAction.js

@@ -1,23 +0,0 @@
-import { encodeFunctionData, erc20Abi } from "viem";
-function preparePrerequisiteAction(result) {
-  if (result.kind === "allowance" && result.satisfied === false) {
-    const { token, spender, required } = result.detail;
-    return {
-      kind: "allowance",
-      to: token,
-      data: encodeFunctionData({
-        abi: erc20Abi,
-        functionName: "approve",
-        args: [spender, required]
-      })
-    };
-  }
-  return null;
-}
-function isActionablePrerequisite(result) {
-  return preparePrerequisiteAction(result) !== null;
-}
-export {
-  isActionablePrerequisite,
-  preparePrerequisiteAction
-};