@bosonprotocol/core-sdk 1.20.1 → 1.21.0-alpha.0

package/src/core-sdk.ts

@@ -14,7 +14,6 @@ import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import { AddressZero } from "@ethersproject/constants";
 import { BytesLike } from "@ethersproject/bytes";
 import { EnvironmentType } from "@bosonprotocol/common/src/types";
-import { ContractTransaction } from "ethers";
 
 import * as accounts from "./accounts";
 import * as disputes from "./disputes";
@@ -25,6 +24,7 @@ import * as erc20 from "./erc20";
 import * as erc721 from "./erc721";
 import * as funds from "./funds";
 import * as metaTx from "./meta-tx";
+import * as nativeMetaTx from "./native-meta-tx";
 import * as metadata from "./metadata";
 import * as subgraph from "./subgraph";
 import * as eventLogs from "./event-logs";
@@ -114,9 +114,23 @@ export class CoreSDK {
   }
 
   public get isMetaTxConfigSet() {
+    return this.checkMetaTxConfigSet();
+  }
+
+  public checkMetaTxConfigSet(
+    args: {
+      contractAddress?: string;
+      metaTransactionMethod?: string;
+    } = {}
+  ) {
+    const contractAddress = args.contractAddress || this._protocolDiamond;
+    const metaTransactionMethod =
+      args.metaTransactionMethod || "executeMetaTransaction";
     return (
       !!this._metaTxConfig &&
-      !!this._metaTxConfig.apiId &&
+      !!this._metaTxConfig.apiIds &&
+      !!this._metaTxConfig.apiIds[contractAddress] &&
+      !!this._metaTxConfig.apiIds[contractAddress][metaTransactionMethod] &&
       !!this._metaTxConfig.apiKey &&
       !!this._metaTxConfig.relayerUrl
     );
@@ -940,6 +954,21 @@ export class CoreSDK {
     });
   }
 
+  public async getProtocolAllowance(
+    exchangeToken: string,
+    overrides: Partial<{
+      spender: string;
+      owner: string;
+    }> = {}
+  ): Promise<string> {
+    return erc20.handler.getAllowance({
+      contractAddress: exchangeToken,
+      owner: overrides.owner || (await this._web3Lib.getSignerAddress()),
+      spender: overrides.spender || this._protocolDiamond,
+      web3Lib: this._web3Lib
+    });
+  }
+
   /* -------------------------------------------------------------------------- */
   /*                            Funds related methods                           */
   /* -------------------------------------------------------------------------- */
@@ -1071,8 +1100,9 @@ export class CoreSDK {
       buyer: string;
     }> = {}
   ): Promise<TransactionResponse> {
+    const buyer = overrides.buyer || (await this._web3Lib.getSignerAddress());
     return exchanges.handler.commitToOffer({
-      buyer: overrides.buyer || (await this._web3Lib.getSignerAddress()),
+      buyer,
       offerId,
       web3Lib: this._web3Lib,
       subgraphUrl: this._subgraphUrl,
@@ -1445,12 +1475,13 @@ export class CoreSDK {
   public async signMetaTxCreateSeller(
     args: Omit<
       Parameters<typeof metaTx.handler.signMetaTxCreateSeller>[0],
-      "web3Lib" | "metaTxHandlerAddress"
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
     >
   ) {
     return metaTx.handler.signMetaTxCreateSeller({
       web3Lib: this._web3Lib,
       metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
       ...args
     });
   }
@@ -1463,12 +1494,13 @@ export class CoreSDK {
   public async signMetaTxCreateOffer(
     args: Omit<
       Parameters<typeof metaTx.handler.signMetaTxCreateOffer>[0],
-      "web3Lib" | "metaTxHandlerAddress"
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
     >
   ) {
     return metaTx.handler.signMetaTxCreateOffer({
       web3Lib: this._web3Lib,
       metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
       ...args
     });
   }
@@ -1481,12 +1513,13 @@ export class CoreSDK {
   public async signMetaTxCreateOfferBatch(
     args: Omit<
       Parameters<typeof metaTx.handler.signMetaTxCreateOfferBatch>[0],
-      "web3Lib" | "metaTxHandlerAddress"
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
     >
   ) {
     return metaTx.handler.signMetaTxCreateOfferBatch({
       web3Lib: this._web3Lib,
       metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
       ...args
     });
   }
@@ -1499,12 +1532,13 @@ export class CoreSDK {
   public async signMetaTxVoidOffer(
     args: Omit<
       Parameters<typeof metaTx.handler.signMetaTxVoidOffer>[0],
-      "web3Lib" | "metaTxHandlerAddress"
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
     >
   ) {
     return metaTx.handler.signMetaTxVoidOffer({
       web3Lib: this._web3Lib,
       metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
       ...args
     });
   }
@@ -1517,12 +1551,13 @@ export class CoreSDK {
   public async signMetaTxVoidOfferBatch(
     args: Omit<
       Parameters<typeof metaTx.handler.signMetaTxVoidOfferBatch>[0],
-      "web3Lib" | "metaTxHandlerAddress"
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
     >
   ) {
     return metaTx.handler.signMetaTxVoidOfferBatch({
       web3Lib: this._web3Lib,
       metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
       ...args
     });
   }
@@ -1535,12 +1570,13 @@ export class CoreSDK {
   public async signMetaTxCompleteExchangeBatch(
     args: Omit<
       Parameters<typeof metaTx.handler.signMetaTxCompleteExchangeBatch>[0],
-      "web3Lib" | "metaTxHandlerAddress"
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
     >
   ) {
     return metaTx.handler.signMetaTxCompleteExchangeBatch({
       web3Lib: this._web3Lib,
       metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
       ...args
     });
   }
@@ -1734,15 +1770,16 @@ export class CoreSDK {
     overrides: Partial<{
       userAddress: string;
       contractAddress: string;
-      metaTxConfig: Partial<MetaTxConfig>;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
     }> = {}
-  ): Promise<ContractTransaction> {
-    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } =
-      this.assertAndGetMetaTxConfig(overrides.metaTxConfig);
+  ): Promise<TransactionResponse> {
+    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl, contractAddress } =
+      this.assertAndGetMetaTxConfig(overrides);
 
     return metaTx.handler.relayMetaTransaction({
       web3LibAdapter: this._web3Lib,
-      contractAddress: overrides.contractAddress || this._protocolDiamond,
+      contractAddress,
       chainId: this._chainId,
       metaTx: {
         config: {
@@ -1764,6 +1801,76 @@ export class CoreSDK {
     });
   }
 
+  /**
+   * Encodes and signs a native "token.approve()" meta transaction that can be relayed.
+   * @param exchangeToken - The address of the token contract.
+   * @param value - The value to be approved.
+   * @param overrides - Optionally specify a spender address (default is the protocol contract address).
+   * @returns Signature.
+   */
+  public async signNativeMetaTxApproveExchangeToken(
+    exchangeToken: string,
+    value: BigNumberish,
+    overrides: Partial<{
+      spender: string;
+    }> = {}
+  ) {
+    const user = await this._web3Lib.getSignerAddress();
+    return nativeMetaTx.handler.signNativeMetaTxApproveExchangeToken({
+      web3Lib: this._web3Lib,
+      chainId: this._chainId,
+      user,
+      exchangeToken,
+      spender: overrides.spender || this._protocolDiamond,
+      value
+    });
+  }
+
+  /**
+   * Relay a native meta transaction,
+   * @param metaTxParams - Required params for meta transaction.
+   * @param overrides - Optional overrides.
+   * @returns Transaction response.
+   */
+  public async relayNativeMetaTransaction(
+    contractAddress: string,
+    metaTxParams: {
+      functionSignature: BytesLike;
+      sigR: BytesLike;
+      sigS: BytesLike;
+      sigV: BigNumberish;
+    },
+    overrides: Partial<{
+      userAddress: string;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
+    }> = {}
+  ): Promise<TransactionResponse> {
+    const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } =
+      this.assertAndGetMetaTxConfig({ ...overrides, contractAddress });
+
+    return nativeMetaTx.handler.relayNativeMetaTransaction({
+      web3LibAdapter: this._web3Lib,
+      contractAddress,
+      chainId: this._chainId,
+      metaTx: {
+        config: {
+          relayerUrl: metaTxRelayerUrl,
+          apiId: metaTxApiId,
+          apiKey: metaTxApiKey
+        },
+        params: {
+          userAddress:
+            overrides.userAddress || (await this._web3Lib.getSignerAddress()),
+          functionSignature: metaTxParams.functionSignature,
+          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.
@@ -1774,11 +1881,13 @@ export class CoreSDK {
   public async getResubmittedMetaTx(
     originalMetaTxHash: string,
     overrides: Partial<{
-      metaTxConfig: Partial<MetaTxConfig>;
+      contractAddress: string;
+      metaTxConfig: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
+      metaTransactionMethod: string;
     }> = {}
   ): Promise<GetRetriedHashesData> {
     const { metaTxApiId, metaTxApiKey, metaTxRelayerUrl } =
-      this.assertAndGetMetaTxConfig(overrides.metaTxConfig);
+      this.assertAndGetMetaTxConfig(overrides);
 
     return metaTx.handler.getResubmitted({
       chainId: this._chainId,
@@ -1794,19 +1903,26 @@ export class CoreSDK {
   }
 
   private assertAndGetMetaTxConfig(
-    metaTxConfigOverrides?: Partial<MetaTxConfig>
+    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 =
-      this._metaTxConfig?.relayerUrl || metaTxConfigOverrides?.relayerUrl;
+      overrides.metaTxConfig?.relayerUrl || this._metaTxConfig?.relayerUrl;
     const metaTxApiKey =
-      this._metaTxConfig?.apiKey || metaTxConfigOverrides?.apiKey;
+      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];
     const metaTxApiId =
-      this._metaTxConfig?.apiId || metaTxConfigOverrides?.apiId;
+      overrides.metaTxConfig?.apiId ||
+      (apiIds && apiIds[metaTransactionMethod]);
 
-    if (
-      !this.isMetaTxConfigSet ||
-      !(metaTxRelayerUrl && metaTxApiKey && metaTxApiId)
-    ) {
+    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."
       );
@@ -1815,7 +1931,8 @@ export class CoreSDK {
     return {
       metaTxRelayerUrl,
       metaTxApiId,
-      metaTxApiKey
+      metaTxApiKey,
+      contractAddress
     };
   }
 

package/src/erc20/handler.ts

@@ -1,5 +1,5 @@
 import { Web3LibAdapter } from "@bosonprotocol/common";
-import { BigNumberish } from "@ethersproject/bignumber";
+import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import { erc20Iface } from "./interface";
 
 export async function approve(args: {
@@ -67,3 +67,17 @@ export async function getName(args: {
   const [name] = erc20Iface.decodeFunctionResult("name", result);
   return String(name);
 }
+
+export async function ensureAllowance(args: {
+  owner: string;
+  spender: string;
+  contractAddress: string;
+  value: BigNumberish;
+  web3Lib: Web3LibAdapter;
+}) {
+  const allowance = await getAllowance(args);
+  if (BigNumber.from(allowance).lt(args.value)) {
+    const approveTx = await approve(args);
+    await approveTx.wait();
+  }
+}

package/src/exchanges/handler.ts

@@ -13,6 +13,7 @@ import {
 import { getOfferById } from "../offers/subgraph";
 import { getExchangeById, getExchanges } from "../exchanges/subgraph";
 import { ExchangeFieldsFragment, ExchangeState } from "../subgraph";
+import { ensureAllowance } from "../erc20/handler";
 
 type BaseExchangeHandlerArgs = {
   contractAddress: string;
@@ -48,6 +49,18 @@ export async function commitToOffer(
     throw new Error(`Offer with id ${args.offerId} is sold out`);
   }
 
+  if (offer.exchangeToken.address !== AddressZero) {
+    const owner = await args.web3Lib.getSignerAddress();
+    // check if we need the committer to approve the token first
+    await ensureAllowance({
+      owner,
+      spender: args.contractAddress,
+      contractAddress: offer.exchangeToken.address,
+      value: offer.price,
+      web3Lib: args.web3Lib
+    });
+  }
+
   return args.web3Lib.sendTransaction({
     from: args.buyer,
     to: args.contractAddress,

package/src/index.ts

@@ -8,6 +8,7 @@ export * as erc20 from "./erc20";
 export * as erc721 from "./erc721";
 export * as funds from "./funds";
 export * as metaTx from "./meta-tx";
+export * as nativeMetaTx from "./native-meta-tx";
 export * as subgraph from "./subgraph";
 
 export {

package/src/meta-tx/biconomy.ts

@@ -36,7 +36,6 @@ export type GetRetriedHashesResponse = {
   code: number;
   message: string;
   data: GetRetriedHashesData;
-  events?: unknown[];
 };
 
 export type GetRetriedHashesArgs = {
@@ -72,13 +71,21 @@ export class Biconomy {
     });
 
     if (!response.ok) {
-      throw new ApiError(
-        response.status,
-        `Failed to relay tx: ${response.statusText}`
-      );
+      let message;
+      try {
+        const jsonResponse = await response.json();
+        message = JSON.stringify(jsonResponse);
+      } catch {
+        message = response.statusText;
+      }
+      throw new ApiError(response.status, `Failed to relay tx: ${message}`);
     }
 
-    return response.json() as Promise<RelayTransactionResponse>;
+    const txResponse = (await response.json()) as RelayTransactionResponse;
+    if (!txResponse.txHash) {
+      throw new ApiError(txResponse.flag, txResponse.log);
+    }
+    return txResponse;
   }
 
   public async getResubmitted(

package/src/meta-tx/handler.ts

@@ -2,11 +2,14 @@ import {
   CreateOfferArgs,
   CreateSellerArgs,
   MetaTxConfig,
-  Web3LibAdapter
+  Web3LibAdapter,
+  TransactionResponse,
+  utils,
+  MetadataStorage
 } from "@bosonprotocol/common";
+import { storeMetadataOnTheGraph } from "../offers/storage";
 import { BigNumber, BigNumberish } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
-import { ContractTransaction } from "@ethersproject/contracts";
 
 import { encodeCreateSeller } from "../accounts/interface";
 import { bosonExchangeHandlerIface } from "../exchanges/interface";
@@ -18,19 +21,27 @@ import {
 import { prepareDataSignatureParameters } from "../utils/signature";
 import { Biconomy, GetRetriedHashesData } from "./biconomy";
 
-type BaseMetaTxArgs = {
+export type BaseMetaTxArgs = {
   web3Lib: Web3LibAdapter;
   nonce: BigNumberish;
   metaTxHandlerAddress: string;
   chainId: number;
 };
 
+export type SignedMetaTx = {
+  functionName: string;
+  functionSignature: string;
+  r: string;
+  s: string;
+  v: number;
+};
+
 export async function signMetaTx(
   args: BaseMetaTxArgs & {
     functionName: string;
     functionSignature: string;
   }
-) {
+): Promise<SignedMetaTx> {
   const metaTransactionType = [
     { name: "nonce", type: "uint256" },
     { name: "from", type: "address" },
@@ -84,8 +95,20 @@ export async function signMetaTxCreateSeller(
 export async function signMetaTxCreateOffer(
   args: BaseMetaTxArgs & {
     createOfferArgs: CreateOfferArgs;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
   }
 ) {
+  utils.validation.createOfferArgsSchema.validateSync(args.createOfferArgs, {
+    abortEarly: false
+  });
+
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.createOfferArgs.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
+
   return signMetaTx({
     ...args,
     functionName:
@@ -97,8 +120,26 @@ export async function signMetaTxCreateOffer(
 export async function signMetaTxCreateOfferBatch(
   args: BaseMetaTxArgs & {
     createOffersArgs: CreateOfferArgs[];
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
   }
 ) {
+  for (const offerToCreate of args.createOffersArgs) {
+    utils.validation.createOfferArgsSchema.validateSync(offerToCreate, {
+      abortEarly: false
+    });
+  }
+
+  await Promise.all(
+    args.createOffersArgs.map((offerToCreate) =>
+      storeMetadataOnTheGraph({
+        metadataUriOrHash: offerToCreate.metadataUri,
+        metadataStorage: args.metadataStorage,
+        theGraphStorage: args.theGraphStorage
+      })
+    )
+  );
+
   return signMetaTx({
     ...args,
     functionName:
@@ -170,7 +211,7 @@ export async function signMetaTxCommitToOffer(
   args: BaseMetaTxArgs & {
     offerId: BigNumberish;
   }
-) {
+): Promise<SignedMetaTx> {
   const functionName = "commitToOffer(address,uint256)";
 
   const offerType = [
@@ -364,7 +405,7 @@ export async function signMetaTxWithdrawFunds(
     tokenList: string[];
     tokenAmounts: BigNumberish[];
   }
-) {
+): Promise<SignedMetaTx> {
   const functionName = "withdrawFunds(uint256,bytes32,bytes32,uint8)";
 
   const fundType = [
@@ -428,7 +469,7 @@ function makeExchangeMetaTxSigner(
     args: BaseMetaTxArgs & {
       exchangeId: BigNumberish;
     }
-  ) {
+  ): Promise<SignedMetaTx> {
     const exchangeType = [{ name: "exchangeId", type: "uint256" }];
 
     const metaTransactionType = [
@@ -481,7 +522,7 @@ export async function relayMetaTransaction(args: {
   chainId: number;
   contractAddress: string;
   metaTx: {
-    config: MetaTxConfig;
+    config: Omit<MetaTxConfig, "apiIds"> & { apiId: string };
     params: {
       userAddress: string;
       functionName: string;
@@ -492,7 +533,7 @@ export async function relayMetaTransaction(args: {
       sigV: BigNumberish;
     };
   };
-}): Promise<ContractTransaction> {
+}): Promise<TransactionResponse> {
   const { chainId, contractAddress, metaTx } = args;
 
   const biconomy = new Biconomy(
@@ -522,43 +563,24 @@ export async function relayMetaTransaction(args: {
         transactionHash: relayTxResponse.txHash
       });
 
-      // TODO: add `getTransaction(hash)` to `Web3LibAdapter` and respective implementations
-      // in ethers and eth-connect flavors. This way we can populate the correct transaction
-      // data below.
+      const txHash = waitResponse.data.newHash;
+      const txReceipt = await args.web3LibAdapter.getTransactionReceipt(txHash);
       return {
-        to: contractAddress,
-        from: metaTx.params.userAddress,
-        contractAddress: contractAddress,
-        transactionIndex: 0,
-        gasUsed: BigNumber.from(0),
-        logsBloom: "",
-        blockHash: "string",
-        transactionHash: waitResponse.data.newHash,
-        logs: [],
-        blockNumber: 0,
-        confirmations: 0,
-        cumulativeGasUsed: BigNumber.from(0),
-        effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice),
-        byzantium: true,
-        type: 0,
-        events: waitResponse.events?.map((event) => JSON.parse(event as string))
+        to: txReceipt?.to || contractAddress,
+        from: txReceipt?.from || metaTx.params.userAddress,
+        transactionHash: txHash,
+        logs: txReceipt?.logs || [],
+        effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice)
       };
     },
-    hash: relayTxResponse.txHash,
-    confirmations: 0,
-    from: metaTx.params.userAddress,
-    nonce: 0,
-    gasLimit: BigNumber.from(0),
-    data: "",
-    value: BigNumber.from(0),
-    chainId: chainId
+    hash: relayTxResponse.txHash
   };
 }
 
 export async function getResubmitted(args: {
   chainId: number;
   metaTx: {
-    config: MetaTxConfig;
+    config: Partial<Omit<MetaTxConfig, "apiIds"> & { apiId: string }>;
     originalHash: string;
   };
 }): Promise<GetRetriedHashesData> {