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

package/dist/cjs/sdk/accounts/CreditAccountsServiceV310.js

@@ -36,7 +36,6 @@ var import_base = require("../base/index.js");
 var import_chains = require("../chain/chains.js");
 var import_constants = require("../constants/index.js");
 var import_market = require("../market/index.js");
-var import_router = require("../router/index.js");
 var import_utils = require("../utils/index.js");
 var import_viem2 = require("../utils/viem/index.js");
 var import_multicall_utils = require("./multicall-utils.js");
@@ -1552,6 +1551,160 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
       callsWithPrices
     );
   }
+  /**
+   * {@inheritDoc ICreditAccountsService.prependPriceUpdates}
+   */
+  async prependPriceUpdates(creditManager, calls, creditAccount, options) {
+    return this.#prependPriceUpdates(
+      creditManager,
+      calls,
+      creditAccount,
+      options
+    );
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.assembleCaUpdateCalls}
+   */
+  assembleCaUpdateCalls({
+    operations,
+    routerCallGroups,
+    creditFacade,
+    withdrawTo,
+    creditAccount,
+    underlyingToken
+  }) {
+    const calls = [];
+    let swapGroupIndex = 0;
+    let routerGroupsConsumed = 0;
+    for (const op of operations) {
+      switch (op.type) {
+        case "increaseDebt":
+          calls.push(this.#prepareIncreaseDebt(creditFacade, op.amount));
+          break;
+        case "decreaseDebt":
+          calls.push(this.#prepareChangeDebt(creditFacade, op.amount, true));
+          break;
+        case "addCollateral":
+          calls.push(
+            ...this.#prepareAddCollateral(
+              creditFacade,
+              [{ token: op.token, balance: op.amount }],
+              {}
+            )
+          );
+          break;
+        case "withdrawCollateral":
+          calls.push(
+            this.#prepareWithdrawToken(
+              creditFacade,
+              op.token,
+              op.amount,
+              withdrawTo
+            )
+          );
+          break;
+        case "swap": {
+          const routerCalls = routerCallGroups[swapGroupIndex];
+          if (!routerCalls) {
+            throw new Error(
+              `assembleCaUpdateCalls: missing router calls for swap leg ${swapGroupIndex}`
+            );
+          }
+          calls.push(...routerCalls);
+          swapGroupIndex += 1;
+          routerGroupsConsumed += 1;
+          break;
+        }
+        case "changeQuota": {
+          const quotaAssets = [...op.quotaIncrease, ...op.quotaDecrease];
+          if (quotaAssets.length === 0) {
+            break;
+          }
+          calls.push(
+            ...this.#prepareUpdateQuotas(creditFacade, {
+              averageQuota: quotaAssets,
+              minQuota: quotaAssets
+            })
+          );
+          break;
+        }
+        case "closeCreditAccount": {
+          for (const group of routerCallGroups) {
+            calls.push(...group);
+            routerGroupsConsumed += 1;
+          }
+          calls.push(
+            ...this.#prepareDisableQuotas({
+              creditFacade,
+              tokens: Object.entries(creditAccount.initialQuotas).map(
+                ([token, { quota }]) => ({
+                  token,
+                  quota
+                })
+              )
+            })
+          );
+          if (creditAccount.debt > 0n) {
+            calls.push(
+              ...this.#prepareDecreaseDebt({
+                creditFacade,
+                debt: creditAccount.debt
+              })
+            );
+          }
+          const hasAssets = creditAccount.assets.some(
+            (asset) => asset.balance > 0n
+          );
+          if (hasAssets) {
+            calls.push(
+              this.#prepareWithdrawToken(
+                creditFacade,
+                underlyingToken,
+                import_constants.MAX_UINT256,
+                withdrawTo
+              )
+            );
+          }
+          break;
+        }
+        default: {
+          const _exhaustive = op;
+          throw new Error(
+            `assembleCaUpdateCalls: unsupported operation ${_exhaustive}`
+          );
+        }
+      }
+    }
+    if (routerGroupsConsumed !== routerCallGroups.length) {
+      throw new Error(
+        `assembleCaUpdateCalls: router call group mismatch (consumed ${routerGroupsConsumed}, got ${routerCallGroups.length})`
+      );
+    }
+    return calls;
+  }
+  /**
+   * {@inheritDoc ICreditAccountsService.executeCaUpdate}
+   */
+  async executeCaUpdate(creditAccount, calls, options) {
+    const cm = this.sdk.marketRegister.findCreditManager(
+      creditAccount.creditManager
+    );
+    const callsWithPrices = await this.#prependPriceUpdates(
+      creditAccount.creditManager,
+      calls,
+      creditAccount,
+      { ignoreReservePrices: options?.ignoreReservePrices }
+    );
+    const tx = await this.#multicallTx(
+      cm,
+      creditAccount.creditAccount,
+      callsWithPrices
+    );
+    if (options?.ethAmount && options.ethAmount > 0n) {
+      tx.value = options.ethAmount.toString(10);
+    }
+    return { tx, calls: callsWithPrices };
+  }
   #prepareDisableQuotas(ca) {
     const calls = [];
     for (const { token, quota } of ca.tokens) {
@@ -1569,10 +1722,10 @@ class CreditAccountsServiceV310 extends import_base.SDKConstruct {
     return calls;
   }
   #prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
-    const minRecord = (0, import_router.assetsMap)(minQuota);
+    const minRecord = new import_utils.AssetsMap(minQuota);
     const calls = averageQuota.map((q) => {
-      const minAsset = minRecord.get(q.token);
-      const min = minAsset && minAsset?.balance > 0 ? minAsset.balance : 0n;
+      const minBalance = minRecord.get(q.token);
+      const min = minBalance && minBalance > 0n ? minBalance : 0n;
       return {
         target: creditFacade,
         callData: (0, import_viem.encodeFunctionData)({

package/dist/cjs/sdk/base/BaseContract.js

@@ -244,6 +244,7 @@ class BaseContract extends import_Construct.Construct {
       const functionName = (0, import_utils.getFunctionSignature)(this.abi, calldata);
       return this.wrapParseCallV2(
         functionName,
+        calldata,
         this.parseFunctionParamsV2(decoded, strict)
       );
     } catch (e) {
@@ -257,7 +258,7 @@ class BaseContract extends import_Construct.Construct {
       this.logger?.warn(e);
       const selector = calldata.slice(0, 10);
       const data = `0x${calldata.slice(10)}`;
-      return this.wrapParseCallV2(`unknown function ${selector}`, {
+      return this.wrapParseCallV2(`unknown function ${selector}`, calldata, {
         _data: data
       });
     }
@@ -270,7 +271,7 @@ class BaseContract extends import_Construct.Construct {
   parseFunctionParamsV2(params, _strict) {
     return (0, import_utils.functionArgsToRecord)(this.abi, params.functionName, params.args);
   }
-  wrapParseCallV2(functionName, rawArgs) {
+  wrapParseCallV2(functionName, calldata, rawArgs) {
     return {
       chainId: this.chainId,
       target: this.address,
@@ -278,6 +279,7 @@ class BaseContract extends import_Construct.Construct {
       label: this.labelAddress(this.address, true),
       version: this.version,
       functionName,
+      calldata,
       rawArgs
     };
   }

package/dist/cjs/sdk/base/ChainContractsRegister.js

@@ -184,6 +184,7 @@ class ChainContractsRegister {
       label: this.labelAddress(address, true),
       version: 0,
       functionName: `unknown function ${selector}`,
+      calldata,
       rawArgs: { _data: data }
     };
   }

package/dist/cjs/sdk/market/MarketRegister.js

@@ -52,10 +52,11 @@ class MarketRegister extends import_ZapperRegister.ZapperRegister {
    * bypassing on-chain reads.
    * @param state - Array of market data snapshots.
    **/
-  hydrate(state) {
-    const configurators = new Set(state.map((m) => m.configurator));
+  hydrate({ markets, zappers }) {
+    const configurators = new Set(markets.map((m) => m.configurator));
     this.#setMarketFilter([...configurators]);
-    this.#setMarkets(state);
+    this.#setMarkets(markets);
+    this.hydrateZappers(zappers);
   }
   /**
    * @internal
@@ -174,7 +175,10 @@ class MarketRegister extends import_ZapperRegister.ZapperRegister {
    * Serializable snapshot of all loaded markets, suitable for hydration.
    **/
   get state() {
-    return this.markets.map((market) => market.state);
+    return {
+      markets: this.markets.map((market) => market.state),
+      zappers: this.zappersState
+    };
   }
   /**
    * Returns a human-readable snapshot of all markets.
@@ -182,7 +186,8 @@ class MarketRegister extends import_ZapperRegister.ZapperRegister {
    **/
   stateHuman(raw = true) {
     return {
-      markets: this.markets.map((market) => market.stateHuman(raw))
+      markets: this.markets.map((market) => market.stateHuman(raw)),
+      zappers: this.zappersStateHuman(raw)
     };
   }
   /**

package/dist/cjs/sdk/market/ZapperRegister.js

@@ -75,6 +75,60 @@ class ZapperRegister extends import_base.SDKConstruct {
       }
     }
   }
+  /**
+   * Serializable snapshot of all loaded zappers, suitable for hydration.
+   * Returns `undefined` when zappers were never loaded (i.e. `loadZappers` was
+   * not called), so the not-loaded state round-trips cleanly.
+   **/
+  get zappersState() {
+    if (!this.#zappers) {
+      return void 0;
+    }
+    return this.#zappers.values().flatMap(
+      (zappers) => zappers.map((z) => ({
+        pool: z.pool,
+        type: z.type,
+        baseParams: z.baseParams,
+        tokenIn: z.tokenIn,
+        tokenOut: z.tokenOut
+      }))
+    );
+  }
+  /**
+   * Restores zapper state from a previously serialized snapshot,
+   * bypassing on-chain reads.
+   * @param state - Array of zapper data snapshots, or `undefined` when zappers
+   *   were not loaded in the snapshot (leaves the registry in the not-loaded state).
+   **/
+  hydrateZappers(state) {
+    if (!state) {
+      return;
+    }
+    this.#zappers = new import_utils.AddressMap(void 0, "zappers");
+    for (const z of state) {
+      this.#addZapper(z);
+    }
+  }
+  /**
+   * Returns a human-readable snapshot of all loaded zappers.
+   * Returns `undefined` when zappers were never loaded.
+   * @param raw - When `true`, includes raw/unformatted values.
+   **/
+  zappersStateHuman(_ = true) {
+    if (!this.#zappers) {
+      return void 0;
+    }
+    return this.#zappers.values().flatMap(
+      (zappers) => zappers.map((z) => ({
+        address: this.labelAddress(z.baseParams.addr),
+        contractType: z.contractType,
+        type: z.type,
+        pool: this.labelAddress(z.pool),
+        tokenIn: this.sdk.labelAddress(z.tokenIn.addr),
+        tokenOut: this.sdk.labelAddress(z.tokenOut.addr)
+      }))
+    );
+  }
   #addZapper(z) {
     const zapper = (0, import_zapper.createZapper)(this.sdk, z);
     const existing = this.zappers.get(z.pool);

package/dist/cjs/sdk/market/rwa/securitize/SecuritizeRWAFactory.js

@@ -70,6 +70,30 @@ class SecuritizeRWAFactory extends import_base.BaseContract {
       operators: [...t.operators]
     }));
   }
+  parseFunctionParamsV2(params, strict) {
+    switch (params.functionName) {
+      case "openCreditAccount": {
+        const [creditManager, calls, tokensToRegister, signaturesToCache] = params.args;
+        return {
+          creditManager,
+          calls: this.register.parseMultiCallV2([...calls], strict),
+          tokensToRegister,
+          signaturesToCache
+        };
+      }
+      case "multicall": {
+        const [creditAccount, calls, tokensToRegister, signaturesToCache] = params.args;
+        return {
+          creditAccount,
+          calls: this.register.parseMultiCallV2([...calls], strict),
+          tokensToRegister,
+          signaturesToCache
+        };
+      }
+      default:
+        return super.parseFunctionParamsV2(params, strict);
+    }
+  }
   /**
    * {@inheritDoc IRWAFactory.decodeInvestorData}
    */
@@ -125,6 +149,12 @@ class SecuritizeRWAFactory extends import_base.BaseContract {
       })
     };
   }
+  /**
+   * {@inheritDoc IRWAFactory.getTokens}
+   */
+  getTokens() {
+    return this.dsTokens.map((t) => t.address);
+  }
   /**
    * {@inheritDoc IRWAFactory.getInvestor}
    */

package/dist/cjs/sdk/market/rwa/types.js

@@ -24,8 +24,11 @@ __export(types_exports, {
 module.exports = __toCommonJS(types_exports);
 var import_securitize = require("./securitize/index.js");
 const RWA_FACTORY_TYPES = [import_securitize.RWA_FACTORY_SECURITIZE];
-function isRWAFactory(factory, type) {
-  return factory.contractType === type;
+function isRWAFactory(contract, type) {
+  if (type) {
+    return contract.contractType === type;
+  }
+  return contract.contractType.startsWith("RWA_FACTORY::");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/market/zapper/IERC20ZapperContract.js

@@ -22,27 +22,11 @@ __export(IERC20ZapperContract_exports, {
 });
 module.exports = __toCommonJS(IERC20ZapperContract_exports);
 var import_iERC20Zapper = require("../../../abi/iERC20Zapper.js");
-var import_base = require("../../base/index.js");
+var import_ZapperContract = require("./ZapperContract.js");
 const abi = import_iERC20Zapper.ierc20ZapperAbi;
-class IERC20ZapperContract extends import_base.BaseContract {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
+class IERC20ZapperContract extends import_ZapperContract.ZapperContract {
   constructor(sdk, data) {
-    super(sdk, {
-      addr: data.baseParams.addr,
-      abi,
-      name: `ERC20Zapper(${sdk.labelAddress(data.baseParams.addr)})`,
-      version: data.baseParams.version,
-      contractType: data.baseParams.contractType
-    });
-    this.pool = data.pool;
-    this.type = data.type;
-    this.baseParams = data.baseParams;
-    this.tokenIn = data.tokenIn;
-    this.tokenOut = data.tokenOut;
+    super(sdk, data, abi, "ERC20Zapper");
   }
   /**
    * Deposits ERC20 tokens into the pool via this zapper.
@@ -72,25 +56,6 @@ class IERC20ZapperContract extends import_base.BaseContract {
       args: [tokenInAmount, receiver, referralCode, deadline, v, r, s]
     });
   }
-  /**
-   * Redeems pool shares (diesel tokens) for the underlying asset via this zapper.
-   */
-  redeem(tokenInAmount, receiver) {
-    return this.createRawTx({
-      functionName: "redeem",
-      args: [tokenInAmount, receiver]
-    });
-  }
-  /**
-   * Redeems pool shares via this zapper with an EIP-2612 permit signature,
-   * skipping a separate approve transaction.
-   */
-  redeemWithPermit(tokenInAmount, receiver, deadline, v, r, s) {
-    return this.createRawTx({
-      functionName: "redeemWithPermit",
-      args: [tokenInAmount, receiver, deadline, v, r, s]
-    });
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/market/zapper/IETHZapperContract.js

@@ -22,27 +22,11 @@ __export(IETHZapperContract_exports, {
 });
 module.exports = __toCommonJS(IETHZapperContract_exports);
 var import_iETHZapper = require("../../../abi/iETHZapper.js");
-var import_base = require("../../base/index.js");
+var import_ZapperContract = require("./ZapperContract.js");
 const abi = import_iETHZapper.iethZapperAbi;
-class IETHZapperContract extends import_base.BaseContract {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
+class IETHZapperContract extends import_ZapperContract.ZapperContract {
   constructor(sdk, data) {
-    super(sdk, {
-      addr: data.baseParams.addr,
-      abi,
-      name: `ETHZapper(${sdk.labelAddress(data.baseParams.addr)})`,
-      version: data.baseParams.version,
-      contractType: data.baseParams.contractType
-    });
-    this.pool = data.pool;
-    this.type = data.type;
-    this.baseParams = data.baseParams;
-    this.tokenIn = data.tokenIn;
-    this.tokenOut = data.tokenOut;
+    super(sdk, data, abi, "ETHZapper");
   }
   /**
    * Deposits native ETH into the pool via this zapper.
@@ -63,25 +47,6 @@ class IETHZapperContract extends import_base.BaseContract {
       args: [receiver, referralCode]
     });
   }
-  /**
-   * Redeems pool shares (diesel tokens) for the underlying asset via this zapper.
-   */
-  redeem(tokenInAmount, receiver) {
-    return this.createRawTx({
-      functionName: "redeem",
-      args: [tokenInAmount, receiver]
-    });
-  }
-  /**
-   * Redeems pool shares via this zapper with an EIP-2612 permit signature,
-   * skipping a separate approve transaction.
-   */
-  redeemWithPermit(tokenInAmount, receiver, deadline, v, r, s) {
-    return this.createRawTx({
-      functionName: "redeemWithPermit",
-      args: [tokenInAmount, receiver, deadline, v, r, s]
-    });
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/market/zapper/ZapperContract.js

@@ -0,0 +1,106 @@
+"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 ZapperContract_exports = {};
+__export(ZapperContract_exports, {
+  ZapperContract: () => ZapperContract
+});
+module.exports = __toCommonJS(ZapperContract_exports);
+var import_iZapper = require("../../../abi/iZapper.js");
+var import_base = require("../../base/index.js");
+var import_errors = require("./errors.js");
+class ZapperContract extends import_base.BaseContract {
+  sdk;
+  pool;
+  type;
+  baseParams;
+  tokenIn;
+  tokenOut;
+  constructor(sdk, data, abi = import_iZapper.iZapperAbi, namePrefix = "Zapper") {
+    super(sdk, {
+      addr: data.baseParams.addr,
+      abi,
+      name: `${namePrefix}(${sdk.labelAddress(data.baseParams.addr)})`,
+      version: data.baseParams.version,
+      contractType: data.baseParams.contractType
+    });
+    this.sdk = sdk;
+    this.pool = data.pool;
+    this.type = data.type;
+    this.baseParams = data.baseParams;
+    this.tokenIn = data.tokenIn;
+    this.tokenOut = data.tokenOut;
+  }
+  /**
+   * Decodes zapper calldata into {@link ParsedZapperOperation}.
+   * Throws {@link UnsupportedZapperFunctionError} for unknown selectors.
+   */
+  parseOperation(calldata, value) {
+    const parsed = this.parseFunctionDataV2(calldata);
+    const { rawArgs } = parsed;
+    const pool = this.pool;
+    const zapper = this.address;
+    const underlying = this.sdk.marketRegister.findByPool(pool).underlying;
+    const receiver = rawArgs.receiver;
+    if (parsed.functionName.startsWith("deposit")) {
+      return {
+        operation: "Deposit",
+        pool,
+        zapper,
+        receiver,
+        assets: rawArgs.tokenInAmount ?? value ?? 0n,
+        underlying,
+        referralCode: rawArgs.referralCode
+      };
+    }
+    if (parsed.functionName.startsWith("redeem")) {
+      return {
+        operation: "Redeem",
+        pool,
+        zapper,
+        receiver,
+        shares: rawArgs.tokenOutAmount,
+        underlying
+      };
+    }
+    throw new import_errors.UnsupportedZapperFunctionError(zapper, parsed.functionName);
+  }
+  /**
+   * Redeems pool shares (diesel tokens) for the underlying asset via this zapper.
+   */
+  redeem(tokenInAmount, receiver) {
+    return this.createRawTx({
+      functionName: "redeem",
+      args: [tokenInAmount, receiver]
+    });
+  }
+  /**
+   * Redeems pool shares via this zapper with an EIP-2612 permit signature,
+   * skipping a separate approve transaction.
+   */
+  redeemWithPermit(tokenInAmount, receiver, deadline, v, r, s) {
+    return this.createRawTx({
+      functionName: "redeemWithPermit",
+      args: [tokenInAmount, receiver, deadline, v, r, s]
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ZapperContract
+});

package/dist/cjs/sdk/market/zapper/createZapper.js

@@ -21,23 +21,31 @@ __export(createZapper_exports, {
   createZapper: () => createZapper
 });
 module.exports = __toCommonJS(createZapper_exports);
+var import_utils = require("../../utils/index.js");
 var import_IERC20ZapperContract = require("./IERC20ZapperContract.js");
 var import_IETHZapperContract = require("./IETHZapperContract.js");
-var import_Zapper = require("./Zapper.js");
+var import_ZapperContract = require("./ZapperContract.js");
 function createZapper(sdk, data) {
+  const existing = sdk.getContract(data.baseParams.addr);
+  if (existing) {
+    return existing;
+  }
   if (data.type === "base") {
-    const contractType = import_Zapper.Zapper.contractType(data.baseParams);
+    const contractType = (0, import_utils.bytes32ToString)(data.baseParams.contractType);
     switch (contractType) {
       case "ZAPPER::ERC4626_UNDERLYING":
         return new import_IERC20ZapperContract.IERC20ZapperContract(sdk, data);
       case "ZAPPER::WETH_DEPOSIT":
         return new import_IETHZapperContract.IETHZapperContract(sdk, data);
       default:
+        if (sdk.strictContractTypes) {
+          throw new Error(`Unknown zapper contract type: ${contractType}`);
+        }
         sdk.logger?.warn(`Unknown zapper contract type: ${contractType}`);
-        return new import_Zapper.Zapper(data);
+        return new import_ZapperContract.ZapperContract(sdk, data);
     }
   }
-  return new import_Zapper.Zapper(data);
+  return new import_ZapperContract.ZapperContract(sdk, data);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/sdk/market/zapper/{Zapper.js → errors.js}

@@ -16,32 +16,22 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Zapper_exports = {};
-__export(Zapper_exports, {
-  Zapper: () => Zapper
+var errors_exports = {};
+__export(errors_exports, {
+  UnsupportedZapperFunctionError: () => UnsupportedZapperFunctionError
 });
-module.exports = __toCommonJS(Zapper_exports);
-var import_utils = require("../../utils/index.js");
-class Zapper {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
-  contractType;
-  constructor(data) {
-    this.pool = data.pool;
-    this.type = data.type;
-    this.baseParams = data.baseParams;
-    this.tokenIn = data.tokenIn;
-    this.tokenOut = data.tokenOut;
-    this.contractType = Zapper.contractType(data.baseParams);
-  }
-  static contractType(baseParams) {
-    return (0, import_utils.bytes32ToString)(baseParams.contractType);
+module.exports = __toCommonJS(errors_exports);
+class UnsupportedZapperFunctionError extends Error {
+  zapper;
+  functionName;
+  constructor(zapper, functionName) {
+    super(`unsupported zapper function "${functionName}" on ${zapper}`);
+    this.name = "UnsupportedZapperFunctionError";
+    this.zapper = zapper;
+    this.functionName = functionName;
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Zapper
+  UnsupportedZapperFunctionError
 });