@gearbox-protocol/sdk 9.9.7 → 9.10.1

package/dist/cjs/dev/AccountOpener.js

@@ -30,6 +30,7 @@ var import_sdk = require("../sdk/index.js");
 var import_abi = require("./abi.js");
 var import_claimFromFaucet = require("./claimFromFaucet.js");
 var import_createAnvilClient = require("./createAnvilClient.js");
+var import_mint = require("./mint/index.js");
 const DIRECT_TRANSFERS_QUOTA = 10000n;
 class OpenTxRevertedError extends import_viem.BaseError {
   txHash;
@@ -501,106 +502,8 @@ class AccountOpener extends import_sdk.SDKConstruct {
    * @param amount
    */
   async #tryMint(token, dest, amount) {
-    const amnt = this.sdk.tokensMeta.formatBN(token, amount, { symbol: true });
-    try {
-      await this.#mint(token, dest, amount);
-    } catch (e) {
-      this.#logger?.warn(`failed to mint ${amnt} to ${dest.address}: ${e}`);
-    }
-    return await this.#anvil.readContract({
-      address: token,
-      abi: import_iERC20.ierc20Abi,
-      functionName: "balanceOf",
-      args: [dest.address]
-    });
-  }
-  async #mint(token, dest, amount) {
-    const symbol = this.sdk.tokensMeta.symbol(token);
-    const amnt = this.sdk.tokensMeta.formatBN(token, amount);
-    this.#logger?.warn(`minting ${amnt} ${symbol} to ${dest.address}`);
-    const owner = await this.#anvil.readContract({
-      address: token,
-      abi: import_abi.iOwnableAbi,
-      functionName: "owner"
-    });
-    this.#logger?.warn(`owner of ${symbol}: ${owner}`);
-    await this.#anvil.impersonateAccount({ address: owner });
-    await this.#anvil.setBalance({
-      address: owner,
-      value: (0, import_viem.parseEther)("1000000")
-    });
-    try {
-      await this.#mintDirectly(owner, token, amount, dest.address);
-    } catch (e) {
-      this.#logger?.warn(
-        `failed to mint directly ${amnt} ${symbol} to ${dest.address}: ${e}`
-      );
-      try {
-        await this.#mintAndTransfer(owner, token, amount, dest.address);
-      } catch (e2) {
-        this.#logger?.warn(
-          `failed to mint and transfer ${amnt} ${symbol} to ${dest.address}: ${e2}`
-        );
-      }
-    }
-    await this.#anvil.stopImpersonatingAccount({ address: owner });
-  }
-  async #mintDirectly(owner, token, amount, dest) {
-    const hash = await this.#anvil.writeContract({
-      account: owner,
-      address: token,
-      abi: (0, import_viem.parseAbi)([
-        "function mint(address to, uint256 amount) returns (bool)"
-      ]),
-      functionName: "mint",
-      args: [dest, amount],
-      chain: this.#anvil.chain
-    });
-    this.#logger?.debug(
-      `mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}`
-    );
-    const receipt = await this.#anvil.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `failed to mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}: reverted`
-      );
-    }
-  }
-  async #mintAndTransfer(owner, token, amount, dest) {
-    let hash = await this.#anvil.writeContract({
-      account: owner,
-      address: token,
-      abi: (0, import_viem.parseAbi)(["function mint(uint256 amount) external returns (bool)"]),
-      functionName: "mint",
-      args: [amount],
-      chain: this.#anvil.chain
-    });
-    this.#logger?.debug(
-      `mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}`
-    );
-    let receipt = await this.#anvil.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `failed to mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}: reverted`
-      );
-    }
-    hash = await this.#anvil.writeContract({
-      account: owner,
-      address: token,
-      abi: import_iERC20.ierc20Abi,
-      functionName: "transfer",
-      args: [dest, amount],
-      chain: this.#anvil.chain
-    });
-    this.#logger?.debug(
-      `transfer ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })}  from ${owner} to ${dest} in tx ${hash}`
-    );
-    receipt = await this.#anvil.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `failed to transfer ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })}  from ${owner} to ${dest} in tx ${hash}: reverted`
-      );
-    }
+    const minter = (0, import_mint.createMinter)(this.sdk, this.#anvil, token);
+    return minter.tryMint(token, dest.address, amount);
   }
   /**
    * Creates borrower wallet,

package/dist/cjs/dev/index.js

@@ -25,6 +25,7 @@ __reExport(dev_exports, require("./detectChain.js"), module.exports);
 __reExport(dev_exports, require("./EthCallSpy.js"), module.exports);
 __reExport(dev_exports, require("./ltUtils.js"), module.exports);
 __reExport(dev_exports, require("./migrateFaucet.js"), module.exports);
+__reExport(dev_exports, require("./mint/index.js"), module.exports);
 __reExport(dev_exports, require("./providers.js"), module.exports);
 __reExport(dev_exports, require("./RevolverTransport.js"), module.exports);
 __reExport(dev_exports, require("./types.js"), module.exports);
@@ -40,6 +41,7 @@ __reExport(dev_exports, require("./types.js"), module.exports);
   ...require("./EthCallSpy.js"),
   ...require("./ltUtils.js"),
   ...require("./migrateFaucet.js"),
+  ...require("./mint/index.js"),
   ...require("./providers.js"),
   ...require("./RevolverTransport.js"),
   ...require("./types.js")

package/dist/cjs/dev/mint/AbstractMinter.js

@@ -0,0 +1,81 @@
+"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 AbstractMinter_exports = {};
+__export(AbstractMinter_exports, {
+  default: () => AbstractMinter
+});
+module.exports = __toCommonJS(AbstractMinter_exports);
+var import_viem = require("viem");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_sdk = require("../../sdk/index.js");
+var import_abi = require("../abi.js");
+class AbstractMinter extends import_sdk.SDKConstruct {
+  anvil;
+  logger;
+  name;
+  constructor(sdk, anvil, name = "Minter") {
+    super(sdk);
+    this.anvil = anvil;
+    this.name = name;
+    this.logger = sdk.logger?.child?.({ name }) ?? sdk.logger;
+  }
+  async tryMint(token, dest, amount) {
+    const amnt = this.fmt(token, amount);
+    const before = await this.balanceOf(token, dest);
+    try {
+      await this.mint(token, dest, amount);
+    } catch (e) {
+      this.logger?.warn(`failed to mint ${amnt} to ${dest}: ${e}`);
+    }
+    const after = await this.balanceOf(token, dest);
+    const minted = after - before;
+    this.logger?.debug(`minted ${this.fmt(token, minted)} to ${dest}`);
+    return after;
+  }
+  async getOwner(address) {
+    const owner = await this.anvil.readContract({
+      address,
+      abi: import_abi.iOwnableAbi,
+      functionName: "owner"
+    });
+    this.logger?.debug(`owner of ${this.sdk.labelAddress(address)}: ${owner}`);
+    return owner;
+  }
+  async impersonateWithBalance(address, balance = "1000") {
+    await this.anvil.impersonateAccount({ address });
+    await this.anvil.setBalance({
+      address,
+      value: (0, import_viem.parseEther)(balance)
+    });
+    return async () => {
+      await this.anvil.stopImpersonatingAccount({ address });
+    };
+  }
+  fmt(token, amount) {
+    return this.sdk.tokensMeta.formatBN(token, amount, { symbol: true });
+  }
+  balanceOf(token, dest) {
+    return this.anvil.readContract({
+      address: token,
+      abi: import_iERC20.ierc20Abi,
+      functionName: "balanceOf",
+      args: [dest]
+    });
+  }
+}

package/dist/cjs/dev/mint/DealMinter.js

@@ -0,0 +1,54 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DealMinter_exports = {};
+__export(DealMinter_exports, {
+  DealMinter: () => DealMinter
+});
+module.exports = __toCommonJS(DealMinter_exports);
+var import_viem_deal = require("viem-deal");
+var import_AbstractMinter = __toESM(require("./AbstractMinter.js"));
+class DealMinter extends import_AbstractMinter.default {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "DealMinter");
+  }
+  async mint(token, dest, amount) {
+    let balance = await this.balanceOf(token, dest);
+    balance += amount;
+    this.logger?.debug(`set balance of ${dest} to ${this.fmt(token, balance)}`);
+    await (0, import_viem_deal.deal)(this.anvil, {
+      erc20: token,
+      account: dest,
+      amount: balance
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DealMinter
+});

package/dist/cjs/dev/mint/DirectMinter.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var DirectMinter_exports = {};
+__export(DirectMinter_exports, {
+  DirectMinter: () => DirectMinter
+});
+module.exports = __toCommonJS(DirectMinter_exports);
+var import_viem = require("viem");
+var import_AbstractMinter = __toESM(require("./AbstractMinter.js"));
+class DirectMinter extends import_AbstractMinter.default {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "DirectMinter");
+  }
+  async mint(token, dest, amount) {
+    const owner = await this.getOwner(token);
+    const stopImpersonating = await this.impersonateWithBalance(owner);
+    const hash = await this.anvil.writeContract({
+      account: owner,
+      address: token,
+      abi: (0, import_viem.parseAbi)([
+        "function mint(address to, uint256 amount) returns (bool)"
+      ]),
+      functionName: "mint",
+      args: [dest, amount],
+      chain: this.anvil.chain
+    });
+    this.logger?.debug(
+      `mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}`
+    );
+    const receipt = await this.anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `failed to mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}: reverted`
+      );
+    }
+    await stopImpersonating();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DirectMinter
+});

package/dist/cjs/dev/mint/FallbackMinter.js

@@ -0,0 +1,57 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var FallbackMinter_exports = {};
+__export(FallbackMinter_exports, {
+  FallbackMinter: () => FallbackMinter
+});
+module.exports = __toCommonJS(FallbackMinter_exports);
+var import_AbstractMinter = __toESM(require("./AbstractMinter.js"));
+class FallbackMinter extends import_AbstractMinter.default {
+  #minters;
+  constructor(sdk, anvil, minters) {
+    super(sdk, anvil, "FallbackMinter");
+    this.#minters = minters;
+  }
+  async mint(token, dest, amount) {
+    for (const minter of this.#minters) {
+      try {
+        await minter.mint(token, dest, amount);
+        this.logger?.debug(`${minter.name} succeeded`);
+        return;
+      } catch (e) {
+        this.logger?.warn(`${minter.name} failed: ${e}`);
+      }
+    }
+    throw new Error("all minters failed");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FallbackMinter
+});

package/dist/cjs/dev/mint/TransferMinter.js

@@ -0,0 +1,84 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var TransferMinter_exports = {};
+__export(TransferMinter_exports, {
+  TransferMinter: () => TransferMinter
+});
+module.exports = __toCommonJS(TransferMinter_exports);
+var import_viem = require("viem");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_AbstractMinter = __toESM(require("./AbstractMinter.js"));
+class TransferMinter extends import_AbstractMinter.default {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "TransferMinter");
+  }
+  async mint(token, dest, amount) {
+    const owner = await this.getOwner(token);
+    const stopImpersonating = await this.impersonateWithBalance(owner);
+    let hash = await this.anvil.writeContract({
+      account: owner,
+      address: token,
+      abi: (0, import_viem.parseAbi)(["function mint(uint256 amount) external returns (bool)"]),
+      functionName: "mint",
+      args: [amount],
+      chain: this.anvil.chain
+    });
+    this.logger?.debug(
+      `mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}`
+    );
+    let receipt = await this.anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `failed to mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}: reverted`
+      );
+    }
+    hash = await this.anvil.writeContract({
+      account: owner,
+      address: token,
+      abi: import_iERC20.ierc20Abi,
+      functionName: "transfer",
+      args: [dest, amount],
+      chain: this.anvil.chain
+    });
+    this.logger?.debug(
+      `transfer ${this.fmt(token, amount)}  from ${owner} to ${dest} in tx ${hash}`
+    );
+    receipt = await this.anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `failed to transfer ${this.fmt(token, amount)} from ${owner} to ${dest} in tx ${hash}: reverted`
+      );
+    }
+    await stopImpersonating();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TransferMinter
+});

package/dist/cjs/dev/mint/factory.js

@@ -0,0 +1,38 @@
+"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 factory_exports = {};
+__export(factory_exports, {
+  createMinter: () => createMinter
+});
+module.exports = __toCommonJS(factory_exports);
+var import_DealMinter = require("./DealMinter.js");
+var import_DirectMinter = require("./DirectMinter.js");
+var import_FallbackMinter = require("./FallbackMinter.js");
+var import_TransferMinter = require("./TransferMinter.js");
+function createMinter(sdk, anvil, token) {
+  return new import_FallbackMinter.FallbackMinter(sdk, anvil, [
+    new import_DealMinter.DealMinter(sdk, anvil),
+    new import_DirectMinter.DirectMinter(sdk, anvil),
+    new import_TransferMinter.TransferMinter(sdk, anvil)
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createMinter
+});

package/dist/cjs/dev/mint/index.js

@@ -0,0 +1,24 @@
+"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 mint_exports = {};
+module.exports = __toCommonJS(mint_exports);
+__reExport(mint_exports, require("./factory.js"), module.exports);
+__reExport(mint_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./factory.js"),
+  ...require("./types.js")
+});

package/dist/cjs/dev/mint/types.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_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/esm/dev/AccountOpener.js

@@ -2,7 +2,6 @@ import {
   BaseError,
   erc20Abi,
   isAddress,
-  parseAbi,
   parseEther,
   parseEventLogs
 } from "viem";
@@ -20,9 +19,10 @@ import {
   SDKConstruct,
   sendRawTx
 } from "../sdk/index.js";
-import { iDegenNftv2Abi, iOwnableAbi } from "./abi.js";
+import { iDegenNftv2Abi } from "./abi.js";
 import { claimFromFaucet } from "./claimFromFaucet.js";
 import { createAnvilClient } from "./createAnvilClient.js";
+import { createMinter } from "./mint/index.js";
 const DIRECT_TRANSFERS_QUOTA = 10000n;
 class OpenTxRevertedError extends BaseError {
   txHash;
@@ -494,106 +494,8 @@ class AccountOpener extends SDKConstruct {
    * @param amount
    */
   async #tryMint(token, dest, amount) {
-    const amnt = this.sdk.tokensMeta.formatBN(token, amount, { symbol: true });
-    try {
-      await this.#mint(token, dest, amount);
-    } catch (e) {
-      this.#logger?.warn(`failed to mint ${amnt} to ${dest.address}: ${e}`);
-    }
-    return await this.#anvil.readContract({
-      address: token,
-      abi: ierc20Abi,
-      functionName: "balanceOf",
-      args: [dest.address]
-    });
-  }
-  async #mint(token, dest, amount) {
-    const symbol = this.sdk.tokensMeta.symbol(token);
-    const amnt = this.sdk.tokensMeta.formatBN(token, amount);
-    this.#logger?.warn(`minting ${amnt} ${symbol} to ${dest.address}`);
-    const owner = await this.#anvil.readContract({
-      address: token,
-      abi: iOwnableAbi,
-      functionName: "owner"
-    });
-    this.#logger?.warn(`owner of ${symbol}: ${owner}`);
-    await this.#anvil.impersonateAccount({ address: owner });
-    await this.#anvil.setBalance({
-      address: owner,
-      value: parseEther("1000000")
-    });
-    try {
-      await this.#mintDirectly(owner, token, amount, dest.address);
-    } catch (e) {
-      this.#logger?.warn(
-        `failed to mint directly ${amnt} ${symbol} to ${dest.address}: ${e}`
-      );
-      try {
-        await this.#mintAndTransfer(owner, token, amount, dest.address);
-      } catch (e2) {
-        this.#logger?.warn(
-          `failed to mint and transfer ${amnt} ${symbol} to ${dest.address}: ${e2}`
-        );
-      }
-    }
-    await this.#anvil.stopImpersonatingAccount({ address: owner });
-  }
-  async #mintDirectly(owner, token, amount, dest) {
-    const hash = await this.#anvil.writeContract({
-      account: owner,
-      address: token,
-      abi: parseAbi([
-        "function mint(address to, uint256 amount) returns (bool)"
-      ]),
-      functionName: "mint",
-      args: [dest, amount],
-      chain: this.#anvil.chain
-    });
-    this.#logger?.debug(
-      `mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}`
-    );
-    const receipt = await this.#anvil.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `failed to mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}: reverted`
-      );
-    }
-  }
-  async #mintAndTransfer(owner, token, amount, dest) {
-    let hash = await this.#anvil.writeContract({
-      account: owner,
-      address: token,
-      abi: parseAbi(["function mint(uint256 amount) external returns (bool)"]),
-      functionName: "mint",
-      args: [amount],
-      chain: this.#anvil.chain
-    });
-    this.#logger?.debug(
-      `mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}`
-    );
-    let receipt = await this.#anvil.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `failed to mint ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })} to ${owner} in tx ${hash}: reverted`
-      );
-    }
-    hash = await this.#anvil.writeContract({
-      account: owner,
-      address: token,
-      abi: ierc20Abi,
-      functionName: "transfer",
-      args: [dest, amount],
-      chain: this.#anvil.chain
-    });
-    this.#logger?.debug(
-      `transfer ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })}  from ${owner} to ${dest} in tx ${hash}`
-    );
-    receipt = await this.#anvil.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `failed to transfer ${this.sdk.tokensMeta.formatBN(token, amount, { symbol: true })}  from ${owner} to ${dest} in tx ${hash}: reverted`
-      );
-    }
+    const minter = createMinter(this.sdk, this.#anvil, token);
+    return minter.tryMint(token, dest.address, amount);
   }
   /**
    * Creates borrower wallet,

package/dist/esm/dev/index.js

@@ -8,6 +8,7 @@ export * from "./detectChain.js";
 export * from "./EthCallSpy.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";
+export * from "./mint/index.js";
 export * from "./providers.js";
 export * from "./RevolverTransport.js";
 export * from "./types.js";

package/dist/esm/dev/mint/AbstractMinter.js

@@ -0,0 +1,63 @@
+import { parseEther } from "viem";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import {
+  SDKConstruct
+} from "../../sdk/index.js";
+import { iOwnableAbi } from "../abi.js";
+class AbstractMinter extends SDKConstruct {
+  anvil;
+  logger;
+  name;
+  constructor(sdk, anvil, name = "Minter") {
+    super(sdk);
+    this.anvil = anvil;
+    this.name = name;
+    this.logger = sdk.logger?.child?.({ name }) ?? sdk.logger;
+  }
+  async tryMint(token, dest, amount) {
+    const amnt = this.fmt(token, amount);
+    const before = await this.balanceOf(token, dest);
+    try {
+      await this.mint(token, dest, amount);
+    } catch (e) {
+      this.logger?.warn(`failed to mint ${amnt} to ${dest}: ${e}`);
+    }
+    const after = await this.balanceOf(token, dest);
+    const minted = after - before;
+    this.logger?.debug(`minted ${this.fmt(token, minted)} to ${dest}`);
+    return after;
+  }
+  async getOwner(address) {
+    const owner = await this.anvil.readContract({
+      address,
+      abi: iOwnableAbi,
+      functionName: "owner"
+    });
+    this.logger?.debug(`owner of ${this.sdk.labelAddress(address)}: ${owner}`);
+    return owner;
+  }
+  async impersonateWithBalance(address, balance = "1000") {
+    await this.anvil.impersonateAccount({ address });
+    await this.anvil.setBalance({
+      address,
+      value: parseEther(balance)
+    });
+    return async () => {
+      await this.anvil.stopImpersonatingAccount({ address });
+    };
+  }
+  fmt(token, amount) {
+    return this.sdk.tokensMeta.formatBN(token, amount, { symbol: true });
+  }
+  balanceOf(token, dest) {
+    return this.anvil.readContract({
+      address: token,
+      abi: ierc20Abi,
+      functionName: "balanceOf",
+      args: [dest]
+    });
+  }
+}
+export {
+  AbstractMinter as default
+};

package/dist/esm/dev/mint/DealMinter.js

@@ -0,0 +1,20 @@
+import { deal } from "viem-deal";
+import AbstractMinter from "./AbstractMinter.js";
+class DealMinter extends AbstractMinter {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "DealMinter");
+  }
+  async mint(token, dest, amount) {
+    let balance = await this.balanceOf(token, dest);
+    balance += amount;
+    this.logger?.debug(`set balance of ${dest} to ${this.fmt(token, balance)}`);
+    await deal(this.anvil, {
+      erc20: token,
+      account: dest,
+      amount: balance
+    });
+  }
+}
+export {
+  DealMinter
+};

package/dist/esm/dev/mint/DirectMinter.js

@@ -0,0 +1,34 @@
+import { parseAbi } from "viem";
+import AbstractMinter from "./AbstractMinter.js";
+class DirectMinter extends AbstractMinter {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "DirectMinter");
+  }
+  async mint(token, dest, amount) {
+    const owner = await this.getOwner(token);
+    const stopImpersonating = await this.impersonateWithBalance(owner);
+    const hash = await this.anvil.writeContract({
+      account: owner,
+      address: token,
+      abi: parseAbi([
+        "function mint(address to, uint256 amount) returns (bool)"
+      ]),
+      functionName: "mint",
+      args: [dest, amount],
+      chain: this.anvil.chain
+    });
+    this.logger?.debug(
+      `mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}`
+    );
+    const receipt = await this.anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `failed to mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}: reverted`
+      );
+    }
+    await stopImpersonating();
+  }
+}
+export {
+  DirectMinter
+};

package/dist/esm/dev/mint/FallbackMinter.js

@@ -0,0 +1,23 @@
+import AbstractMinter from "./AbstractMinter.js";
+class FallbackMinter extends AbstractMinter {
+  #minters;
+  constructor(sdk, anvil, minters) {
+    super(sdk, anvil, "FallbackMinter");
+    this.#minters = minters;
+  }
+  async mint(token, dest, amount) {
+    for (const minter of this.#minters) {
+      try {
+        await minter.mint(token, dest, amount);
+        this.logger?.debug(`${minter.name} succeeded`);
+        return;
+      } catch (e) {
+        this.logger?.warn(`${minter.name} failed: ${e}`);
+      }
+    }
+    throw new Error("all minters failed");
+  }
+}
+export {
+  FallbackMinter
+};

package/dist/esm/dev/mint/TransferMinter.js

@@ -0,0 +1,50 @@
+import { parseAbi } from "viem";
+import { ierc20Abi } from "../../abi/iERC20.js";
+import AbstractMinter from "./AbstractMinter.js";
+class TransferMinter extends AbstractMinter {
+  constructor(sdk, anvil) {
+    super(sdk, anvil, "TransferMinter");
+  }
+  async mint(token, dest, amount) {
+    const owner = await this.getOwner(token);
+    const stopImpersonating = await this.impersonateWithBalance(owner);
+    let hash = await this.anvil.writeContract({
+      account: owner,
+      address: token,
+      abi: parseAbi(["function mint(uint256 amount) external returns (bool)"]),
+      functionName: "mint",
+      args: [amount],
+      chain: this.anvil.chain
+    });
+    this.logger?.debug(
+      `mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}`
+    );
+    let receipt = await this.anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `failed to mint ${this.fmt(token, amount)} to ${owner} in tx ${hash}: reverted`
+      );
+    }
+    hash = await this.anvil.writeContract({
+      account: owner,
+      address: token,
+      abi: ierc20Abi,
+      functionName: "transfer",
+      args: [dest, amount],
+      chain: this.anvil.chain
+    });
+    this.logger?.debug(
+      `transfer ${this.fmt(token, amount)}  from ${owner} to ${dest} in tx ${hash}`
+    );
+    receipt = await this.anvil.waitForTransactionReceipt({ hash });
+    if (receipt.status === "reverted") {
+      throw new Error(
+        `failed to transfer ${this.fmt(token, amount)} from ${owner} to ${dest} in tx ${hash}: reverted`
+      );
+    }
+    await stopImpersonating();
+  }
+}
+export {
+  TransferMinter
+};

package/dist/esm/dev/mint/factory.js

@@ -0,0 +1,14 @@
+import { DealMinter } from "./DealMinter.js";
+import { DirectMinter } from "./DirectMinter.js";
+import { FallbackMinter } from "./FallbackMinter.js";
+import { TransferMinter } from "./TransferMinter.js";
+function createMinter(sdk, anvil, token) {
+  return new FallbackMinter(sdk, anvil, [
+    new DealMinter(sdk, anvil),
+    new DirectMinter(sdk, anvil),
+    new TransferMinter(sdk, anvil)
+  ]);
+}
+export {
+  createMinter
+};

package/dist/esm/dev/mint/index.js

@@ -0,0 +1,2 @@
+export * from "./factory.js";
+export * from "./types.js";

package/dist/types/dev/index.d.ts

@@ -8,6 +8,7 @@ export * from "./detectChain.js";
 export * from "./EthCallSpy.js";
 export * from "./ltUtils.js";
 export * from "./migrateFaucet.js";
+export * from "./mint/index.js";
 export * from "./providers.js";
 export * from "./RevolverTransport.js";
 export * from "./types.js";

package/dist/types/dev/mint/AbstractMinter.d.ts

@@ -0,0 +1,16 @@
+import { type Address } from "viem";
+import { type GearboxSDK, type ILogger, SDKConstruct } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
+import type { IMinter } from "./types.js";
+export default abstract class AbstractMinter extends SDKConstruct implements IMinter {
+    protected readonly anvil: AnvilClient;
+    protected readonly logger?: ILogger;
+    readonly name: string;
+    constructor(sdk: GearboxSDK, anvil: AnvilClient, name?: string);
+    tryMint(token: Address, dest: Address, amount: bigint): Promise<bigint>;
+    abstract mint(token: Address, dest: Address, amount: bigint): Promise<void>;
+    protected getOwner(address: Address): Promise<Address>;
+    protected impersonateWithBalance(address: Address, balance?: string): Promise<() => Promise<void>>;
+    protected fmt(token: Address, amount: bigint): string;
+    protected balanceOf(token: Address, dest: Address): Promise<bigint>;
+}

package/dist/types/dev/mint/DealMinter.d.ts

@@ -0,0 +1,9 @@
+import type { Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
+import AbstractMinter from "./AbstractMinter.js";
+import type { IMinter } from "./types.js";
+export declare class DealMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
+    mint(token: Address, dest: Address, amount: bigint): Promise<void>;
+}

package/dist/types/dev/mint/DirectMinter.d.ts

@@ -0,0 +1,9 @@
+import { type Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
+import AbstractMinter from "./AbstractMinter.js";
+import type { IMinter } from "./types.js";
+export declare class DirectMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
+    mint(token: Address, dest: Address, amount: bigint): Promise<void>;
+}

package/dist/types/dev/mint/FallbackMinter.d.ts

@@ -0,0 +1,10 @@
+import type { Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
+import AbstractMinter from "./AbstractMinter.js";
+import type { IMinter } from "./types.js";
+export declare class FallbackMinter extends AbstractMinter implements IMinter {
+    #private;
+    constructor(sdk: GearboxSDK, anvil: AnvilClient, minters: IMinter[]);
+    mint(token: Address, dest: Address, amount: bigint): Promise<void>;
+}

package/dist/types/dev/mint/TransferMinter.d.ts

@@ -0,0 +1,9 @@
+import { type Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient.js";
+import AbstractMinter from "./AbstractMinter.js";
+import type { IMinter } from "./types.js";
+export declare class TransferMinter extends AbstractMinter implements IMinter {
+    constructor(sdk: GearboxSDK, anvil: AnvilClient);
+    mint(token: Address, dest: Address, amount: bigint): Promise<void>;
+}

package/dist/types/dev/mint/factory.d.ts

@@ -0,0 +1,5 @@
+import type { Address } from "viem";
+import type { GearboxSDK } from "../../sdk/index.js";
+import type { AnvilClient } from "../createAnvilClient";
+import type { IMinter } from "./types.js";
+export declare function createMinter(sdk: GearboxSDK, anvil: AnvilClient, token: Address): IMinter;

package/dist/types/dev/mint/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./factory.js";
+export * from "./types.js";

package/dist/types/dev/mint/types.d.ts

@@ -0,0 +1,20 @@
+import type { Address } from "viem";
+export interface IMinter {
+    /**
+     * Tries to mint tokens, returns the balance after attempt (success or not)
+     * If mint failed, does not throw
+     * @param token
+     * @param dest
+     * @param amount
+     */
+    tryMint: (token: Address, dest: Address, amount: bigint) => Promise<bigint>;
+    /**
+     * Tries to mint tokens, throws if failed
+     * @param token
+     * @param dest
+     * @param amount
+     * @returns
+     */
+    mint: (token: Address, dest: Address, amount: bigint) => Promise<void>;
+    name: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "9.9.7",
+  "version": "9.10.1",
   "description": "Gearbox SDK",
   "license": "MIT",
   "main": "./dist/cjs/sdk/index.js",
@@ -65,23 +65,25 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.4",
-    "@commitlint/cli": "^20.0.0",
+    "@commitlint/cli": "^20.1.0",
     "@commitlint/config-conventional": "^20.0.0",
     "@gearbox-protocol/biome-config": "^1.0.2",
     "@types/cross-spawn": "^6.0.6",
     "axios": "^1.12.2",
     "cross-spawn": "^7.0.6",
     "husky": "^9.1.7",
-    "lint-staged": "^16.2.1",
-    "pino": "^9.11.0",
+    "lint-staged": "^16.2.3",
+    "pino": "^9.12.0",
     "pino-pretty": "^13.1.1",
     "tsup": "^8.5.0",
     "tsx": "^4.20.6",
     "typescript": "^5.9.2",
+    "viem-deal": "^2.0.4",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "axios": "^1.0.0"
+    "axios": "^1.0.0",
+    "viem-deal": "^2.0.4"
   },
   "commitlint": {
     "extends": [