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

package/dist/cjs/preview/parse/errors.js

@@ -0,0 +1,47 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  UnsupportedPoolFunctionError: () => UnsupportedPoolFunctionError,
+  UnsupportedTargetError: () => UnsupportedTargetError
+});
+module.exports = __toCommonJS(errors_exports);
+class UnsupportedTargetError extends Error {
+  target;
+  constructor(target) {
+    super(`unsupported transaction target: ${target}`);
+    this.name = "UnsupportedTargetError";
+    this.target = target;
+  }
+}
+class UnsupportedPoolFunctionError extends Error {
+  pool;
+  functionName;
+  constructor(pool, functionName) {
+    super(`unsupported pool function "${functionName}" on ${pool}`);
+    this.name = "UnsupportedPoolFunctionError";
+    this.pool = pool;
+    this.functionName = functionName;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UnsupportedPoolFunctionError,
+  UnsupportedTargetError
+});

package/dist/cjs/preview/parse/extractExpectedBalanceChanges.js

@@ -0,0 +1,48 @@
+"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 extractExpectedBalanceChanges_exports = {};
+__export(extractExpectedBalanceChanges_exports, {
+  extractExpectedBalanceChanges: () => extractExpectedBalanceChanges
+});
+module.exports = __toCommonJS(extractExpectedBalanceChanges_exports);
+function extractExpectedBalanceChanges(innerCalls) {
+  const calls = innerCalls.filter(
+    (call) => functionName(call) !== "onDemandPriceUpdates"
+  );
+  if (calls.length === 0) {
+    return void 0;
+  }
+  const first = calls[0];
+  const last = calls[calls.length - 1];
+  if (functionName(first) !== "storeExpectedBalances" || functionName(last) !== "compareBalances") {
+    return void 0;
+  }
+  const balanceDeltas = first.rawArgs.balanceDeltas;
+  if (!balanceDeltas) {
+    return void 0;
+  }
+  return balanceDeltas.map(({ token, amount }) => ({ token, delta: amount }));
+}
+function functionName(call) {
+  return call.functionName.split("(")[0];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractExpectedBalanceChanges
+});

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

@@ -0,0 +1,34 @@
+"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 parse_exports = {};
+module.exports = __toCommonJS(parse_exports);
+__reExport(parse_exports, require("./classifyInnerOperations.js"), module.exports);
+__reExport(parse_exports, require("./errors.js"), module.exports);
+__reExport(parse_exports, require("./extractExpectedBalanceChanges.js"), module.exports);
+__reExport(parse_exports, require("./parseFacadeOperationCalldata.js"), module.exports);
+__reExport(parse_exports, require("./parseOperationCalldata.js"), module.exports);
+__reExport(parse_exports, require("./parsePoolOperationCalldata.js"), module.exports);
+__reExport(parse_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./classifyInnerOperations.js"),
+  ...require("./errors.js"),
+  ...require("./extractExpectedBalanceChanges.js"),
+  ...require("./parseFacadeOperationCalldata.js"),
+  ...require("./parseOperationCalldata.js"),
+  ...require("./parsePoolOperationCalldata.js"),
+  ...require("./types.js")
+});

package/dist/cjs/preview/parse/parseFacadeOperationCalldata.js

@@ -0,0 +1,115 @@
+"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 parseFacadeOperationCalldata_exports = {};
+__export(parseFacadeOperationCalldata_exports, {
+  parseFacadeOperationCalldata: () => parseFacadeOperationCalldata
+});
+module.exports = __toCommonJS(parseFacadeOperationCalldata_exports);
+var import_viem = require("viem");
+var import_classifyInnerOperations = require("./classifyInnerOperations.js");
+var import_extractExpectedBalanceChanges = require("./extractExpectedBalanceChanges.js");
+function parseFacadeOperationCalldata(props) {
+  const { sdk, facade, calldata } = props;
+  const parsed = sdk.parseFunctionDataV2(facade.address, calldata);
+  const functionName = parsed.functionName.split("(")[0];
+  const { rawArgs } = parsed;
+  const suite = sdk.marketRegister.creditManagers.find(
+    (cm) => (0, import_viem.isAddressEqual)(cm.creditFacade.address, facade.address)
+  );
+  if (!suite) {
+    throw new Error(`no credit suite found for facade ${facade.address}`);
+  }
+  const metadata = {
+    creditManager: suite.creditManager.address,
+    creditFacade: facade.address
+  };
+  const innerCalls = rawArgs.calls ?? [];
+  const multicall = (0, import_classifyInnerOperations.classifyInnerOperations)(innerCalls, {
+    sdk,
+    underlying: suite.underlying
+  });
+  const expectedBalanceChanges = (0, import_extractExpectedBalanceChanges.extractExpectedBalanceChanges)(innerCalls);
+  switch (functionName) {
+    case "multicall":
+      return {
+        ...metadata,
+        operation: "MultiCall",
+        creditAccount: rawArgs.creditAccount,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "botMulticall":
+      return {
+        ...metadata,
+        operation: "BotMulticall",
+        creditAccount: rawArgs.creditAccount,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "openCreditAccount":
+      return {
+        ...metadata,
+        operation: "OpenCreditAccount",
+        creditAccount: import_viem.zeroAddress,
+        onBehalfOf: rawArgs.onBehalfOf,
+        referralCode: rawArgs.referralCode,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "closeCreditAccount":
+      return {
+        ...metadata,
+        operation: "CloseCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "liquidateCreditAccount":
+      return {
+        ...metadata,
+        operation: "LiquidateCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        to: rawArgs.to,
+        // `token` and `remainingFunds` are only emitted on-chain during
+        // liquidation, so they are not recoverable from raw calldata.
+        token: import_viem.zeroAddress,
+        remainingFunds: 0n,
+        multicall,
+        expectedBalanceChanges
+      };
+    case "partiallyLiquidateCreditAccount":
+      return {
+        ...metadata,
+        operation: "PartiallyLiquidateCreditAccount",
+        creditAccount: rawArgs.creditAccount,
+        token: rawArgs.token,
+        repaidAmount: rawArgs.repaidAmount,
+        minSeizedAmount: rawArgs.minSeizedAmount,
+        to: rawArgs.to
+      };
+    default:
+      throw new Error(
+        `unsupported credit facade function "${parsed.functionName}" on ${facade.address}`
+      );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseFacadeOperationCalldata
+});

package/dist/cjs/preview/parse/parseOperationCalldata.js

@@ -0,0 +1,46 @@
+"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 parseOperationCalldata_exports = {};
+__export(parseOperationCalldata_exports, {
+  parseOperationCalldata: () => parseOperationCalldata
+});
+module.exports = __toCommonJS(parseOperationCalldata_exports);
+var import_sdk = require("../../sdk/index.js");
+var import_errors = require("./errors.js");
+var import_parseFacadeOperationCalldata = require("./parseFacadeOperationCalldata.js");
+var import_parsePoolOperationCalldata = require("./parsePoolOperationCalldata.js");
+function parseOperationCalldata(input) {
+  const { sdk, to, calldata } = input;
+  const contract = sdk.getContract(to);
+  if (contract instanceof import_sdk.PoolV310Contract) {
+    return (0, import_parsePoolOperationCalldata.parsePoolOperationCalldata)({ sdk, pool: contract, calldata });
+  }
+  if (contract instanceof import_sdk.CreditFacadeV310Contract) {
+    return (0, import_parseFacadeOperationCalldata.parseFacadeOperationCalldata)({
+      sdk,
+      facade: contract,
+      calldata
+    });
+  }
+  throw new import_errors.UnsupportedTargetError(to);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseOperationCalldata
+});

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

@@ -0,0 +1,77 @@
+"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 parsePoolOperationCalldata_exports = {};
+__export(parsePoolOperationCalldata_exports, {
+  parsePoolOperationCalldata: () => parsePoolOperationCalldata
+});
+module.exports = __toCommonJS(parsePoolOperationCalldata_exports);
+var import_errors = require("./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,
+        referralCode: functionName === "depositWithReferral" ? rawArgs.referralCode : void 0
+      };
+    case "mint":
+    case "mintWithReferral":
+      return {
+        operation: "Mint",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        shares: rawArgs.shares,
+        underlying,
+        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
+      };
+    case "redeem":
+      return {
+        operation: "Redeem",
+        pool: pool.address,
+        receiver: rawArgs.receiver,
+        owner: rawArgs.owner,
+        shares: rawArgs.shares,
+        underlying
+      };
+    default:
+      throw new import_errors.UnsupportedPoolFunctionError(pool.address, parsed.functionName);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parsePoolOperationCalldata
+});

package/dist/cjs/{history/inner-operations.js → preview/parse/types-adapters.js}

@@ -12,5 +12,5 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var inner_operations_exports = {};
-module.exports = __toCommonJS(inner_operations_exports);
+var types_adapters_exports = {};
+module.exports = __toCommonJS(types_adapters_exports);

package/dist/cjs/preview/parse/types-facades.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_facades_exports = {};
+module.exports = __toCommonJS(types_facades_exports);

package/dist/cjs/preview/parse/types-pools.js

@@ -0,0 +1,16 @@
+"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_pools_exports = {};
+module.exports = __toCommonJS(types_pools_exports);

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

@@ -0,0 +1,37 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  isPoolOperation: () => isPoolOperation
+});
+module.exports = __toCommonJS(types_exports);
+__reExport(types_exports, require("./types-adapters.js"), module.exports);
+__reExport(types_exports, require("./types-facades.js"), module.exports);
+__reExport(types_exports, require("./types-pools.js"), module.exports);
+function isPoolOperation(tx) {
+  return tx.operation === "Deposit" || tx.operation === "Mint" || tx.operation === "Withdraw" || tx.operation === "Redeem";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isPoolOperation,
+  ...require("./types-adapters.js"),
+  ...require("./types-facades.js"),
+  ...require("./types-pools.js")
+});

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,77 @@
+"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_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() {
+    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
+});