@gearbox-protocol/sdk 14.12.0-next.11 → 14.12.0-next.13

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

@@ -1,47 +0,0 @@
-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
-  }));
-}
-export {
-  verifyPrerequisites
-};

package/dist/types/preview/prerequisites/buildPrerequisites.d.ts

@@ -1,25 +0,0 @@
-import { type PluginsMap } from "../../sdk/index.js";
-import { type ParseOperationCalldataInput } from "../parse/parseOperationCalldata.js";
-import type { AnyPrerequisite } from "./Prerequisite.js";
-/**
- * Input of {@link buildPrerequisites}: the same raw-calldata input as the
- * internal calldata parser, plus an optional block to read at.
- */
-export type BuildPrerequisitesInput<P extends PluginsMap = PluginsMap> = ParseOperationCalldataInput<P> & {
-    /** Block to read at; defaults to latest. Only set for testnet forks. */
-    blockNumber?: bigint;
-};
-/**
- * Derives the on-chain prerequisites for an operation given its raw calldata:
- * the conditions that must hold for the call not to revert and that we can
- * verify with the SDK (token approvals, wallet balances). The calldata is
- * decoded internally via `parseOperationCalldata`.
- *
- * Only *sender-actionable* prerequisites belong here: conditions the LP
- * provider or borrower can fix themselves before retrying (e.g. approve a
- * token, top up a balance). Non-actionable protocol/admin state (pool pause,
- * available pool liquidity, health factor, liquidatability, degen NFT gating,
- * bot permissions) is intentionally out of scope, since the user cannot
- * resolve it. New {@link AnyPrerequisite} subclasses must follow the same rule.
- */
-export declare function buildPrerequisites<P extends PluginsMap>(input: BuildPrerequisitesInput<P>): Promise<AnyPrerequisite[]>;

package/dist/types/preview/prerequisites/prepareAction.d.ts

@@ -1,52 +0,0 @@
-import { type Address, type Hex } from "viem";
-import type { AnyPrerequisiteResult } from "./types.js";
-/**
- * A single transaction that satisfies a sender-actionable prerequisite.
- *
- * The shape is intentionally minimal (`to`/`data`/optional `value`) so it maps
- * directly onto wallet send primitives (e.g. viem `sendTransaction`, wagmi
- * `useSendTransaction`/`useWriteContract`). It is deliberately *not* the heavier
- * {@link import("../../sdk/types/transactions.js").RawTx} used for Safe batches.
- *
- * The `kind` mirrors the prerequisite kind it remediates, so consumers can label
- * the action (e.g. "Approve") without re-deriving it.
- */
-export interface PrerequisiteAction {
-    /** Prerequisite kind this action remediates. */
-    kind: "allowance";
-    /** Contract the transaction is sent to (the ERC-20 token for allowances). */
-    to: Address;
-    /** Encoded calldata (e.g. `approve(spender, required)`). */
-    data: Hex;
-    /** Native value to send; omitted (treated as 0) for ERC-20 approvals. */
-    value?: bigint;
-}
-/**
- * Builds the transaction that resolves an unsatisfied, sender-actionable
- * prerequisite, or returns `null` when the prerequisite cannot be fixed with a
- * single wallet transaction.
- *
- * Currently only `allowance` is actionable: it returns an ERC-20
- * `approve(spender, required)` for the exact required amount. `balance`
- * shortfalls (the user must acquire/free up funds) and errored reads are not
- * actionable and return `null`. New actionable kinds (permits, native unwrap,
- * approve-reset-to-zero for non-standard tokens, ...) should be encoded here so
- * consumers do not have to special-case them.
- *
- * Operates on the serializable {@link AnyPrerequisiteResult} produced by
- * `verifyPrerequisites` (not on {@link import("./Prerequisite.js").Prerequisite}
- * instances), so it works against cached/persisted results.
- *
- * @param result - A verified prerequisite result.
- * @returns The remediation transaction, or `null` if not auto-actionable.
- */
-export declare function preparePrerequisiteAction(result: AnyPrerequisiteResult): PrerequisiteAction | null;
-/**
- * Whether a prerequisite result represents something the sender can fix with a
- * single wallet transaction (i.e. {@link preparePrerequisiteAction} returns a
- * transaction for it).
- *
- * Useful for UIs that distinguish "approve to continue" (actionable) from hard
- * blocks like an insufficient balance (not actionable).
- */
-export declare function isActionablePrerequisite(result: AnyPrerequisiteResult): boolean;

package/dist/types/preview/prerequisites/runPrerequisites.d.ts

@@ -1,12 +0,0 @@
-import type { AnyPrerequisite } from "./Prerequisite.js";
-import type { AnyPrerequisiteResult, PrerequisiteContext } from "./types.js";
-/**
- * Verifies all prerequisites in a single resilient multicall.
- *
- * Every prereq contributes its reads to one `multicall({ allowFailure: true })`
- * batch, then resolves its own slice of the response. A read that reverts
- * isolates to that prerequisite (an `error` result) without affecting the
- * others; if the whole round-trip fails (RPC/network), every prerequisite
- * resolves to an `error` carrying that reason.
- */
-export declare function verifyPrerequisites(prereqs: AnyPrerequisite[], ctx: PrerequisiteContext): Promise<AnyPrerequisiteResult[]>;