@bosonprotocol/core-sdk 1.23.0-alpha.16 → 1.23.0-alpha.18

package/src/meta-tx/mixin.ts

@@ -0,0 +1,515 @@
+import { MetaTxConfig, TransactionResponse } from "@bosonprotocol/common";
+import { BigNumberish } from "@ethersproject/bignumber";
+import { BytesLike } from "@ethersproject/bytes";
+import { handler } from ".";
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import { GetRetriedHashesData } from "./biconomy";
+export class MetaTxMixin extends BaseCoreSDK {
+  /* -------------------------------------------------------------------------- */
+  /*                           Meta Tx related methods                          */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Encodes and signs a meta transaction that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTx(
+    args: Omit<
+      Parameters<typeof handler.signMetaTx>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTx({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `createSeller` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCreateSeller(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCreateSeller>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCreateSeller({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `createOffer` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCreateOffer(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCreateOffer>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCreateOffer({
+      web3Lib: this._web3Lib,
+      theGraphStorage: this._theGraphStorage,
+      metadataStorage: this._metadataStorage,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `createOfferBatch` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCreateOfferBatch(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCreateOfferBatch>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCreateOfferBatch({
+      web3Lib: this._web3Lib,
+      theGraphStorage: this._theGraphStorage,
+      metadataStorage: this._metadataStorage,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `createGroup` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCreateGroup(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCreateGroup>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCreateGroup({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `createOfferWithCondition` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCreateOfferWithCondition(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCreateOfferWithCondition>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCreateOfferWithCondition({
+      web3Lib: this._web3Lib,
+      theGraphStorage: this._theGraphStorage,
+      metadataStorage: this._metadataStorage,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `voidOffer` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxVoidOffer(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxVoidOffer>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxVoidOffer({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `voidOfferBatch` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxVoidOfferBatch(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxVoidOfferBatch>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxVoidOfferBatch({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `completeExchangeBatch` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCompleteExchange(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCompleteExchange>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCompleteExchange({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `completeExchangeBatch` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCompleteExchangeBatch(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCompleteExchangeBatch>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCompleteExchangeBatch({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `commitToOffer` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCommitToOffer(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCommitToOffer>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCommitToOffer({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `cancelVoucher` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxCancelVoucher(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCancelVoucher>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxCancelVoucher({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `redeemVoucher` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxRedeemVoucher(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxRedeemVoucher>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxRedeemVoucher({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `expireVoucher` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxExpireVoucher(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxExpireVoucher>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxExpireVoucher({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `revokeVoucher` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxRevokeVoucher(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxRevokeVoucher>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxRevokeVoucher({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `retractDispute` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxRetractDispute(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxRetractDispute>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxRetractDispute({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `escalateDispute` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxEscalateDispute(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxEscalateDispute>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxEscalateDispute({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `raiseDispute` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxRaiseDispute(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxRaiseDispute>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxRaiseDispute({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `resolveDispute` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxResolveDispute(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxResolveDispute>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxResolveDispute({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `extendDisputeTimeout` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxExtendDisputeTimeout(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxExtendDisputeTimeout>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxExtendDisputeTimeout({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `withdrawFunds` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxWithdrawFunds(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxWithdrawFunds>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxWithdrawFunds({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `depositFunds` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxDepositFunds(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxDepositFunds>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxDepositFunds({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Relay a meta transaction,
+   * @param metaTxParams - Required params for meta transaction.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async relayMetaTransaction(
+    metaTxParams: {
+      functionName: string;
+      functionSignature: BytesLike;
+      nonce: BigNumberish;
+      sigR: BytesLike;
+      sigS: BytesLike;
+      sigV: BigNumberish;
+    },
+    overrides: Partial<{
+      userAddress: string;
+      contractAddress: string;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl, contractAddress } =
+      this.assertAndGetMetaTxConfig(overrides);
+
+    return handler.relayMetaTransaction({
+      web3LibAdapter: this._web3Lib,
+      contractAddress,
+      chainId: this._chainId,
+      metaTx: {
+        config: {
+          relayerUrl: metaTxRelayerUrl,
+          apiId: metaTxApiId,
+          apiKey: metaTxApiKey
+        },
+        params: {
+          userAddress:
+            overrides.userAddress || (await this._web3Lib.getSignerAddress()),
+          functionName: metaTxParams.functionName,
+          functionSignature: metaTxParams.functionSignature,
+          nonce: metaTxParams.nonce,
+          sigR: metaTxParams.sigR,
+          sigS: metaTxParams.sigS,
+          sigV: metaTxParams.sigV
+        }
+      }
+    });
+  }
+
+  /**
+   * Returns information of submitted meta transaction.
+   * See https://docs.biconomy.io/api/native-meta-tx/get-retried-hashes.
+   * @param originalMetaTxHash - Original meta transaction as returned by `coreSDK.relayMetaTransaction`
+   * @param overrides - Optional overrides for meta transaction config.
+   * @returns - Additional meta transaction information.
+   */
+  public async getResubmittedMetaTx(
+    originalMetaTxHash: string,
+    overrides: Partial<{
+      contractAddress: string;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
+    }> = {}
+  ): Promise<GetRetriedHashesData> {
+    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } =
+      this.assertAndGetMetaTxConfig(overrides);
+
+    return handler.getResubmitted({
+      chainId: this._chainId,
+      metaTx: {
+        config: {
+          relayerUrl: metaTxRelayerUrl,
+          apiId: metaTxApiId,
+          apiKey: metaTxApiKey
+        },
+        originalHash: originalMetaTxHash
+      }
+    });
+  }
+}

package/src/metadata/mixin.ts

@@ -0,0 +1,85 @@
+import { BaseCoreSDK } from "./../mixins/base-core-sdk";
+import * as metadata from ".";
+import * as subgraph from "../subgraph";
+import { AnyMetadata } from "..";
+
+export class MetadataMixin extends BaseCoreSDK {
+  /* -------------------------------------------------------------------------- */
+  /*                          Metadata related methods                          */
+  /* -------------------------------------------------------------------------- */
+
+  /**
+   * Stores supported offer metadata via the MetadataStorage instance which was passed in
+   * at construction.
+   * @param metadata - Offer metadata of type `BASE` or `PRODUCT_V1`.
+   * @returns Metadata hash / identifier.
+   */
+  public async storeMetadata(metadata: AnyMetadata): Promise<string> {
+    if (!this._metadataStorage) {
+      throw new Error("No metadata storage set");
+    }
+
+    return this._metadataStorage.storeMetadata(metadata);
+  }
+
+  /**
+   * Returns supported offer metadata from passed in `MetadataStorage` instance.
+   * @param metadataHashOrUri - Metadata hash or uri that can be handled by the
+   * storage instance.
+   * @returns Offer metadata.
+   */
+  public async getMetadata(metadataHashOrUri: string): Promise<AnyMetadata> {
+    if (!this._metadataStorage) {
+      throw new Error("No metadata storage set");
+    }
+
+    return this._metadataStorage.getMetadata(metadataHashOrUri);
+  }
+
+  /**
+   * Returns `BASE` type offer metadata entities from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns BaseMetadataEntities from subgraph.
+   */
+  public async getBaseMetadataEntities(
+    queryVars?: subgraph.GetBaseMetadataEntitiesQueryQueryVariables
+  ): Promise<subgraph.BaseMetadataEntityFieldsFragment[]> {
+    return metadata.subgraph.getBaseMetadataEntities(
+      this._subgraphUrl,
+      queryVars
+    );
+  }
+
+  /**
+   * Returns `PRODUCT_V1` type offer metadata entities from subgraph.
+   * @param queryVars - Optional query variables to skip, order or filter.
+   * @returns ProductV1MetadataEntities from subgraph.
+   */
+  public async getProductV1MetadataEntities(
+    queryVars?: subgraph.GetProductV1MetadataEntitiesQueryQueryVariables
+  ): Promise<subgraph.ProductV1MetadataEntityFieldsFragment[]> {
+    return metadata.subgraph.getProductV1MetadataEntities(
+      this._subgraphUrl,
+      queryVars
+    );
+  }
+
+  public async getProductV1Products(
+    queryVars?: subgraph.GetProductV1ProductsQueryQueryVariables
+  ): Promise<subgraph.BaseProductV1ProductFieldsFragment[]> {
+    return metadata.subgraph.getProductV1Products(this._subgraphUrl, queryVars);
+  }
+
+  public async getProductWithVariants(productUuid: string): Promise<{
+    product: subgraph.BaseProductV1ProductFieldsFragment;
+    variants: Array<{
+      offer: subgraph.OfferFieldsFragment;
+      variations: Array<subgraph.ProductV1Variation>;
+    }>;
+  } | null> {
+    return metadata.subgraph.getProductWithVariants(
+      this._subgraphUrl,
+      productUuid
+    );
+  }
+}

package/src/mixins/base-core-sdk.ts

@@ -0,0 +1,96 @@
+import {
+  Web3LibAdapter,
+  MetadataStorage,
+  MetaTxConfig,
+  LensContracts
+} from "@bosonprotocol/common";
+import { TokenInfoManager } from "../utils/tokenInfoManager";
+
+export class BaseCoreSDK {
+  protected _web3Lib: Web3LibAdapter;
+  protected _metadataStorage?: MetadataStorage;
+  protected _theGraphStorage?: MetadataStorage;
+
+  protected _subgraphUrl: string;
+  protected _protocolDiamond: string;
+  protected _chainId: number;
+  protected _tokenInfoManager: TokenInfoManager;
+
+  protected _metaTxConfig?: Partial<MetaTxConfig>;
+  protected _lensContracts?: LensContracts;
+
+  /**
+   * Creates an instance of `BaseCoreSDK`
+   * @param args - Constructor args
+   */
+  constructor(opts: {
+    web3Lib: Web3LibAdapter;
+    subgraphUrl: string;
+    protocolDiamond: string;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
+    chainId: number;
+    metaTx?: Partial<MetaTxConfig>;
+    lensContracts?: LensContracts;
+  }) {
+    this._web3Lib = opts.web3Lib;
+    this._subgraphUrl = opts.subgraphUrl;
+    this._protocolDiamond = opts.protocolDiamond;
+    this._metadataStorage = opts.metadataStorage;
+    this._theGraphStorage = opts.theGraphStorage;
+    this._chainId = opts.chainId;
+    this._metaTxConfig = opts.metaTx;
+    this._lensContracts = opts.lensContracts;
+  }
+
+  protected assertAndGetMetaTxConfig(
+    overrides: Partial<{
+      contractAddress: string;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
+    }> = {}
+  ) {
+    const contractAddress = overrides.contractAddress || this._protocolDiamond;
+    const metaTransactionMethod =
+      overrides.metaTransactionMethod || "executeMetaTransaction";
+    const metaTxRelayerUrl =
+      overrides.metaTxConfig?.relayerUrl || this._metaTxConfig?.relayerUrl;
+    const metaTxApiKey =
+      overrides.metaTxConfig?.apiKey || this._metaTxConfig?.apiKey;
+    // metaTxApiId is depending on the contract/method(=executeMetaTransaction) to be called with Biconomy
+    const apiIds = this._metaTxConfig?.apiIds[contractAddress.toLowerCase()];
+    const metaTxApiId =
+      overrides.metaTxConfig?.apiId ||
+      (apiIds && apiIds[metaTransactionMethod]);
+
+    if (!(metaTxRelayerUrl && metaTxApiKey && metaTxApiId)) {
+      throw new Error(
+        "CoreSDK not configured to relay meta transactions. Either pass in 'relayerUrl', 'apiKey' and 'apiId' during initialization OR as overrides arguments."
+      );
+    }
+
+    return {
+      metaTxRelayerUrl,
+      metaTxApiId,
+      metaTxApiKey,
+      contractAddress
+    };
+  }
+}
+
+// Doc: https://www.typescriptlang.org/docs/handbook/mixins.html#alternative-pattern
+export function applyMixins(
+  derivedCtor: typeof BaseCoreSDK,
+  constructors: typeof BaseCoreSDK[]
+) {
+  constructors.forEach((baseCtor) => {
+    Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
+      Object.defineProperty(
+        derivedCtor.prototype,
+        name,
+        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
+          Object.create(null)
+      );
+    });
+  });
+}