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

package/dist/esm/preview/preview/unwrapNativeCollateral.js

@@ -0,0 +1,21 @@
+import { AssetsMap, NATIVE_ADDRESS } from "../../sdk/index.js";
+import { InvalidTransactionValueError } from "./errors.js";
+function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
+  if (nativeAmount === 0n) {
+    return collateral;
+  }
+  const balances = new AssetsMap(collateral);
+  const wethBalance = balances.get(wethToken) ?? 0n;
+  if (wethBalance < nativeAmount) {
+    throw new InvalidTransactionValueError(nativeAmount, wethBalance);
+  }
+  balances.upsert(
+    wethToken,
+    wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount
+  );
+  balances.inc(NATIVE_ADDRESS, nativeAmount);
+  return balances.toAssets();
+}
+export {
+  unwrapNativeCollateral
+};

package/dist/esm/preview/simulate/errors.js

@@ -27,11 +27,6 @@ function asPreviewSimulationError(reason, source) {
     { source, detail: decodeSimulationError({ error }) }
   ]);
 }
-function combinePreviewSimulationErrors(...errors) {
-  return new PreviewSimulationError(
-    errors.filter((e) => e).flatMap((e) => e?.failures ?? [])
-  );
-}
 function decodeSimulationError(revert) {
   const { error, data } = revert;
   if (data && data !== "0x") {
@@ -70,6 +65,5 @@ function formatDecodedError(errorName, args) {
 export {
   PreviewSimulationError,
   asPreviewSimulationError,
-  combinePreviewSimulationErrors,
   decodeSimulationError
 };

package/dist/esm/preview/simulate/index.js

@@ -1,12 +1,12 @@
-import { ETH_SIMULATE_V1_NETWORKS } from "./constants.js";
 import { PreviewSimulationError } from "./errors.js";
 import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulateOperation } from "./simulateOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
+import { simulateRWAOperation } from "./simulateRWAOperation.js";
 export {
-  ETH_SIMULATE_V1_NETWORKS,
   PreviewSimulationError,
   simulateFacadeOperation,
   simulateOperation,
-  simulatePoolOperation
+  simulatePoolOperation,
+  simulateRWAOperation
 };

package/dist/esm/preview/simulate/simulateOperation.js

@@ -1,11 +1,18 @@
-import { isPoolOperation } from "../parse/index.js";
+import {
+  isPoolOperation,
+  isRWAOperation
+} from "../parse/index.js";
 import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
+import { simulateRWAOperation } from "./simulateRWAOperation.js";
 async function simulateOperation(input, options) {
   const { operation } = input;
   if (isPoolOperation(operation)) {
     return simulatePoolOperation({ ...input, operation }, options);
   }
+  if (isRWAOperation(operation)) {
+    return simulateRWAOperation({ ...input, operation }, options);
+  }
   return simulateFacadeOperation({ ...input, operation }, options);
 }
 export {

package/dist/esm/preview/simulate/simulatePoolOperation.js

@@ -1,40 +1,66 @@
-import { ETH_SIMULATE_V1_NETWORKS } from "./constants.js";
-import {
-  asPreviewSimulationError,
-  combinePreviewSimulationErrors
-} from "./errors.js";
-import { simulatePoolOpMulticall } from "./simulatePoolOpMulticall.js";
-import { simulatePoolOpV1 } from "./simulatePoolOpV1.js";
-async function simulatePoolOperation(input, options = {}) {
-  const { sdk } = input;
-  const { logger } = options;
-  const useSimulateV1 = options.useSimulateV1 ?? ETH_SIMULATE_V1_NETWORKS.has(sdk.networkType);
-  logger?.debug(
-    { wallet: input.wallet, to: input.to },
-    "simulating pool operation"
-  );
-  const [v1, multicall] = await Promise.allSettled([
-    useSimulateV1 ? simulatePoolOpV1(input, options) : void 0,
-    simulatePoolOpMulticall(input, options)
-  ]);
-  if (v1.status === "fulfilled" && v1.value) {
-    return { status: "success", ...v1.value };
+import { iPoolV310Abi } from "../../abi/310/generated.js";
+import { iZapperAbi } from "../../abi/iZapper.js";
+import { asPreviewSimulationError } from "./errors.js";
+function previewRead(operation) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { functionName: "previewDeposit", amount: operation.assets };
+    case "Mint":
+      return { functionName: "previewMint", amount: operation.shares };
+    case "Withdraw":
+      return { functionName: "previewWithdraw", amount: operation.assets };
+    case "Redeem":
+      return { functionName: "previewRedeem", amount: operation.shares };
+  }
+}
+function previewContract(operation) {
+  const { functionName, amount } = previewRead(operation);
+  if (operation.zapper) {
+    return {
+      address: operation.zapper,
+      abi: iZapperAbi,
+      functionName,
+      args: [amount]
+    };
   }
-  if (multicall.status === "fulfilled") {
-    if (v1.status === "rejected") {
-      logger?.debug(
-        asPreviewSimulationError(v1.reason, "eth_simulateV1"),
-        "eth_simulateV1 flow failed; falling back to multicall result"
-      );
-    }
-    return { status: "success", ...multicall.value };
+  return {
+    address: operation.pool,
+    abi: iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+}
+function amountsInOut(operation, previewAmount) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { amountIn: operation.assets, amountOut: previewAmount };
+    case "Mint":
+      return { amountIn: previewAmount, amountOut: operation.shares };
+    case "Withdraw":
+      return { amountIn: previewAmount, amountOut: operation.assets };
+    case "Redeem":
+      return { amountIn: operation.shares, amountOut: previewAmount };
+  }
+}
+async function simulatePoolOperation(input, options = {}) {
+  const { sdk, operation } = input;
+  const { blockNumber, logger } = options;
+  try {
+    const previewAmount = await sdk.client.readContract({
+      // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+      // testnet forks pinned to a specific block.
+      blockNumber,
+      ...previewContract(operation)
+    });
+    return {
+      status: "success",
+      ...amountsInOut(operation, previewAmount)
+    };
+  } catch (cause) {
+    const error = asPreviewSimulationError(cause, "multicall");
+    logger?.error(error, "pool operation simulation failed");
+    return { status: "failure", error };
   }
-  const error = combinePreviewSimulationErrors(
-    v1.status === "rejected" ? asPreviewSimulationError(v1.reason, "eth_simulateV1") : void 0,
-    asPreviewSimulationError(multicall.reason, "multicall")
-  );
-  logger?.error(error, "pool operation simulation failed");
-  return { status: "failure", error };
 }
 export {
   simulatePoolOperation

package/dist/esm/preview/simulate/simulateRWAOperation.js

@@ -0,0 +1,6 @@
+async function simulateRWAOperation(_input, _options) {
+  throw new Error("not yet implemented");
+}
+export {
+  simulateRWAOperation
+};

package/dist/esm/sdk/MultichainSDK.js

@@ -67,6 +67,7 @@ class MultichainSDK {
         const perChainOpts = options?.perChain?.[network] ?? {};
         return sdk.attach({
           ...perChainOpts,
+          loadZappers: perChainOpts.loadZappers ?? options?.loadZappers,
           redstone: {
             ...options?.redstone,
             cache: this.#redstoneCache,

package/dist/esm/sdk/OnchainSDK.js

@@ -126,7 +126,8 @@ class OnchainSDK extends ChainContractsRegister {
       ignoreMarkets,
       marketConfigurators: mcs,
       redstone,
-      pyth
+      pyth,
+      loadZappers
     } = options ?? {};
     const marketConfigurators = mcs ?? TypedObjectUtils.keys(
       this.client.chain.defaultMarketConfigurators
@@ -195,6 +196,9 @@ class OnchainSDK extends ChainContractsRegister {
         blockNumber: this.currentBlock,
         gas: this.gasLimit
       });
+      if (loadZappers) {
+        await this.#marketRegister.loadZappers();
+      }
     }
     const pluginsList = TypedObjectUtils.entries(this.plugins);
     const pluginResponse = await Promise.allSettled(
@@ -247,7 +251,7 @@ class OnchainSDK extends ChainContractsRegister {
       `address provider version: ${this.#addressProvider.version}`
     );
     this.#marketRegister = new MarketRegister(this, ignoreMarkets);
-    this.#marketRegister.hydrate(state.markets);
+    this.#marketRegister.hydrate(state);
     this.#rwa = new RWARegistry(this);
     this.#rwa.setState(state.rwa);
     for (const [name, plugin] of TypedObjectUtils.entries(this.plugins)) {
@@ -312,7 +316,7 @@ class OnchainSDK extends ChainContractsRegister {
       currentBlock: this.currentBlock,
       timestamp: this.timestamp,
       addressProvider: this.addressProvider.state,
-      markets: this.marketRegister.state,
+      ...this.marketRegister.state,
       rwa: this.#rwa.state,
       plugins: Object.fromEntries(
         TypedObjectUtils.entries(this.plugins).map(([name, plugin]) => [

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

@@ -27,8 +27,7 @@ import {
 import {
   getRawPriceUpdates
 } from "../market/index.js";
-import { assetsMap } from "../router/index.js";
-import { AddressMap, AddressSet, hexEq } from "../utils/index.js";
+import { AddressMap, AddressSet, AssetsMap, hexEq } from "../utils/index.js";
 import { simulateWithPriceUpdates } from "../utils/viem/index.js";
 import {
   extractPriceUpdates,
@@ -1718,10 +1717,10 @@ class CreditAccountsServiceV310 extends SDKConstruct {
     return calls;
   }
   #prepareUpdateQuotas(creditFacade, { averageQuota, minQuota }) {
-    const minRecord = assetsMap(minQuota);
+    const minRecord = new 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: encodeFunctionData({

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

@@ -234,6 +234,7 @@ class BaseContract extends Construct {
       const functionName = getFunctionSignature(this.abi, calldata);
       return this.wrapParseCallV2(
         functionName,
+        calldata,
         this.parseFunctionParamsV2(decoded, strict)
       );
     } catch (e) {
@@ -247,7 +248,7 @@ class BaseContract extends 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
       });
     }
@@ -260,7 +261,7 @@ class BaseContract extends Construct {
   parseFunctionParamsV2(params, _strict) {
     return functionArgsToRecord(this.abi, params.functionName, params.args);
   }
-  wrapParseCallV2(functionName, rawArgs) {
+  wrapParseCallV2(functionName, calldata, rawArgs) {
     return {
       chainId: this.chainId,
       target: this.address,
@@ -268,6 +269,7 @@ class BaseContract extends Construct {
       label: this.labelAddress(this.address, true),
       version: this.version,
       functionName,
+      calldata,
       rawArgs
     };
   }

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

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

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

@@ -35,10 +35,11 @@ class MarketRegister extends 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
@@ -157,7 +158,10 @@ class MarketRegister extends 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.
@@ -165,7 +169,8 @@ class MarketRegister extends 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/esm/sdk/market/ZapperRegister.js

@@ -55,6 +55,60 @@ class ZapperRegister extends 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 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 = createZapper(this.sdk, z);
     const existing = this.zappers.get(z.pool);

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

@@ -1,4 +1,6 @@
-import { decodeAbiParameters } from "viem";
+import {
+  decodeAbiParameters
+} from "viem";
 import { iSecuritizeRWAFactoryAbi } from "../../../../abi/rwa/iSecuritizeRWAFactory.js";
 import { BaseContract } from "../../../base/index.js";
 import { AddressMap, AddressSet } from "../../../utils/index.js";
@@ -49,6 +51,30 @@ class SecuritizeRWAFactory extends 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}
    */
@@ -104,6 +130,12 @@ class SecuritizeRWAFactory extends BaseContract {
       })
     };
   }
+  /**
+   * {@inheritDoc IRWAFactory.getTokens}
+   */
+  getTokens() {
+    return this.dsTokens.map((t) => t.address);
+  }
   /**
    * {@inheritDoc IRWAFactory.getInvestor}
    */

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

@@ -1,7 +1,10 @@
 import { RWA_FACTORY_SECURITIZE } from "./securitize/index.js";
 const RWA_FACTORY_TYPES = [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::");
 }
 export {
   RWA_FACTORY_TYPES,

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

@@ -1,25 +1,9 @@
 import { ierc20ZapperAbi } from "../../../abi/iERC20Zapper.js";
-import { BaseContract } from "../../base/index.js";
+import { ZapperContract } from "./ZapperContract.js";
 const abi = ierc20ZapperAbi;
-class IERC20ZapperContract extends BaseContract {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
+class IERC20ZapperContract extends 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.
@@ -49,25 +33,6 @@ class IERC20ZapperContract extends 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]
-    });
-  }
 }
 export {
   IERC20ZapperContract

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

@@ -1,25 +1,9 @@
 import { iethZapperAbi } from "../../../abi/iETHZapper.js";
-import { BaseContract } from "../../base/index.js";
+import { ZapperContract } from "./ZapperContract.js";
 const abi = iethZapperAbi;
-class IETHZapperContract extends BaseContract {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
+class IETHZapperContract extends 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.
@@ -40,25 +24,6 @@ class IETHZapperContract extends 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]
-    });
-  }
 }
 export {
   IETHZapperContract

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

@@ -0,0 +1,82 @@
+import { iZapperAbi } from "../../../abi/iZapper.js";
+import { BaseContract } from "../../base/index.js";
+import { UnsupportedZapperFunctionError } from "./errors.js";
+class ZapperContract extends BaseContract {
+  sdk;
+  pool;
+  type;
+  baseParams;
+  tokenIn;
+  tokenOut;
+  constructor(sdk, data, abi = 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 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]
+    });
+  }
+}
+export {
+  ZapperContract
+};