@bosonprotocol/core-sdk 1.25.0-alpha.9 → 1.25.0

package/src/index.ts

@@ -13,6 +13,7 @@ export * as subgraph from "./subgraph";
 export * as groups from "./groups";
 export * as forwarder from "./forwarder";
 export * as voucher from "./voucher";
+export * as seaport from "./seaport";
 
 export {
   defaultConfigs,
@@ -26,6 +27,7 @@ export {
 export {
   MetadataType,
   AnyMetadata,
+  OfferOrSellerMetadata,
   validateMetadata,
   base,
   productV1

package/src/meta-tx/biconomy.ts

@@ -44,13 +44,46 @@ export type GetRetriedHashesArgs = {
   transactionHash: string;
 };
 
+export type ForwarderDomainData = {
+  name: string;
+  version: string;
+  verifyingContract: string;
+  salt: string;
+};
+
 export class Biconomy {
   public constructor(
     private _relayerUrl: string,
-    private _apiKey: string,
-    private _apiId: string
+    private _apiKey?: string,
+    private _apiId?: string
   ) {}
 
+  public async getForwarderDomainDetails(
+    args: { chainId: number },
+    overrides: Partial<{
+      relayerUrl: string;
+      forwarderAddress: string;
+    }> = {}
+  ): Promise<{ [key: string]: ForwarderDomainData }> {
+    const url = `${
+      overrides.relayerUrl || this._relayerUrl
+    }/api/v2/meta-tx/systemInfo?networkId=${args.chainId}`;
+    const response = await fetch(url, { method: "GET" });
+
+    if (!response.ok) {
+      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}`);
+    }
+    const txResponse = await response.json();
+    return txResponse?.forwarderDomainDetails;
+  }
+
   public async relayTransaction(
     args: RelayTransactionArgs,
     overrides: Partial<RelayOverrides> = {}

package/src/meta-tx/handler.ts

@@ -30,21 +30,31 @@ import {
   encodeReserveRange
 } from "../offers/interface";
 import { prepareDataSignatureParameters } from "../utils/signature";
-import { Biconomy, GetRetriedHashesData } from "./biconomy";
+import {
+  Biconomy,
+  ForwarderDomainData,
+  GetRetriedHashesData
+} from "./biconomy";
 import { isAddress } from "@ethersproject/address";
 import { AddressZero } from "@ethersproject/constants";
 import { encodeDepositFunds, encodeWithdrawFunds } from "../funds/interface";
 import { bosonDisputeHandlerIface } from "../disputes/interface";
 import { encodeCreateGroup } from "../groups/interface";
 import { encodeCreateOfferWithCondition } from "../orchestration/interface";
-import { encodePreMint, encodeSetApprovalForAll } from "../voucher/interface";
+import {
+  encodeCallExternalContract,
+  encodePreMint,
+  encodeSetApprovalForAll,
+  encodeSetApprovalForAllToContract
+} from "../voucher/interface";
 import { hexZeroPad } from "@ethersproject/bytes";
 import { keccak256 } from "@ethersproject/keccak256";
 import { id } from "@ethersproject/hash";
 import { defaultAbiCoder } from "@ethersproject/abi";
 import { ERC20ForwardRequest } from "../forwarder/biconomy-interface";
-import { verifyEIP712 } from "../forwarder/handler";
+import { getNonce, verifyEIP712 } from "../forwarder/handler";
 import { MockForwardRequest } from "../forwarder/mock-interface";
+import { isTrustedForwarder, owner } from "../voucher/handler";
 
 export type BaseMetaTxArgs = {
   web3Lib: Web3LibAdapter;
@@ -55,9 +65,7 @@ export type BaseMetaTxArgs = {
 
 export type BaseVoucherMetaTxArgs = {
   web3Lib: Web3LibAdapter;
-  nonce: BigNumberish;
   bosonVoucherAddress: string;
-  forwarderAddress: string;
   chainId: number;
 };
 
@@ -121,7 +129,9 @@ export async function signMetaTx(
 
 export async function signVoucherMetaTx(
   args: BaseVoucherMetaTxArgs & {
+    forwarderAbi: typeof abis.MockForwarderABI;
     functionSignature: string;
+    forwarderAddress: string;
   }
 ): Promise<SignedVoucherMetaTx> {
   const forwardType = [
@@ -143,11 +153,17 @@ export async function signVoucherMetaTx(
 
   const signerAddress = await args.web3Lib.getSignerAddress();
   const chainId = await args.web3Lib.getChainId();
+  const nonce = await getNonce({
+    contractAddress: args.forwarderAddress,
+    user: signerAddress,
+    web3Lib: args.web3Lib,
+    forwarderAbi: args.forwarderAbi
+  });
 
   const message = {
     from: signerAddress,
     to: args.bosonVoucherAddress,
-    nonce: args.nonce,
+    nonce,
     data: args.functionSignature
   };
 
@@ -181,6 +197,7 @@ export async function signBiconomyVoucherMetaTx(
       | typeof abis.MockForwarderABI
       | typeof abis.BiconomyForwarderABI;
     txGas: BigNumberish;
+    relayerUrl: string;
   }
 ): Promise<SignedVoucherMetaTx> {
   const customSignatureType = {
@@ -208,6 +225,43 @@ export async function signBiconomyVoucherMetaTx(
   const signerAddress = await args.web3Lib.getSignerAddress();
   const chainId = await args.web3Lib.getChainId();
 
+  // Check which forwarder needs to be used for the contract
+  const biconomyForwarderDomainDetails = await new Biconomy(
+    args.relayerUrl
+  ).getForwarderDomainDetails({ chainId });
+
+  const biconomyForwarderDomainData = await new Promise<
+    ForwarderDomainData | undefined
+    // eslint-disable-next-line no-async-promise-executor
+  >(async (resolve, reject) => {
+    try {
+      for (const bFDD of Object.values(biconomyForwarderDomainDetails)) {
+        const ret = await isTrustedForwarder({
+          forwarder: bFDD.verifyingContract,
+          contractAddress: args.bosonVoucherAddress,
+          web3Lib: args.web3Lib
+        });
+        if (ret) {
+          resolve(bFDD);
+        }
+      }
+      resolve(undefined);
+    } catch (e) {
+      reject(e);
+    }
+  });
+  if (!biconomyForwarderDomainData) {
+    throw `Unable to find the trusted forwarder for BosonVoucher contract ${args.bosonVoucherAddress}`;
+  }
+
+  const nonce = await getNonce({
+    contractAddress: biconomyForwarderDomainData.verifyingContract,
+    user: signerAddress,
+    web3Lib: args.web3Lib,
+    batchId: args.batchId,
+    forwarderAbi: args.forwarderAbi
+  });
+
   const message = {
     from: signerAddress,
     to: args.bosonVoucherAddress,
@@ -215,22 +269,15 @@ export async function signBiconomyVoucherMetaTx(
     txGas: args.txGas,
     tokenGasPrice: "0",
     batchId: args.batchId,
-    batchNonce: args.nonce,
+    batchNonce: nonce,
     deadline: Math.floor(Date.now() / 1000 + 3600),
     data: args.functionSignature
   };
 
-  const biconomyForwarderDomainData = {
-    name: "Biconomy Forwarder",
-    version: "1",
-    verifyingContract: args.forwarderAddress,
-    salt: hexZeroPad(BigNumber.from(chainId).toHexString(), 32)
-  };
-
   const signatureParams = await prepareDataSignatureParameters({
     ...args,
     chainId,
-    verifyingContractAddress: args.forwarderAddress,
+    verifyingContractAddress: biconomyForwarderDomainData.verifyingContract,
     customSignatureType,
     primaryType: "ERC20ForwardRequest",
     message,
@@ -263,7 +310,7 @@ export async function signBiconomyVoucherMetaTx(
   // verify signature
   const signatureVerified = await verifyEIP712({
     request: message,
-    contractAddress: args.forwarderAddress,
+    contractAddress: biconomyForwarderDomainData.verifyingContract,
     web3Lib: args.web3Lib,
     domainSeparator,
     forwarderAbi: args.forwarderAbi,
@@ -340,12 +387,19 @@ export async function relayBiconomyMetaTransaction(args: {
 export async function signMetaTxCreateSeller(
   args: BaseMetaTxArgs & {
     createSellerArgs: CreateSellerArgs;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
   }
 ) {
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.createSellerArgs.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
   return signMetaTx({
     ...args,
     functionName:
-      "createSeller((uint256,address,address,address,address,bool),(uint256,uint8),(string,uint256))",
+      "createSeller((uint256,address,address,address,address,bool,string),(uint256,uint8),(string,uint256))",
     functionSignature: encodeCreateSeller(args.createSellerArgs)
   });
 }
@@ -353,12 +407,19 @@ export async function signMetaTxCreateSeller(
 export async function signMetaTxUpdateSeller(
   args: BaseMetaTxArgs & {
     updateSellerArgs: UpdateSellerArgs;
+    metadataStorage?: MetadataStorage;
+    theGraphStorage?: MetadataStorage;
   }
 ) {
+  await storeMetadataOnTheGraph({
+    metadataUriOrHash: args.updateSellerArgs.metadataUri,
+    metadataStorage: args.metadataStorage,
+    theGraphStorage: args.theGraphStorage
+  });
   return signMetaTx({
     ...args,
     functionName:
-      "updateSeller((uint256,address,address,address,address,bool),(uint256,uint8))",
+      "updateSeller((uint256,address,address,address,address,bool,string),(uint256,uint8))",
     functionSignature: encodeUpdateSeller(args.updateSellerArgs)
   });
 }
@@ -460,6 +521,38 @@ export async function signMetaTxVoidOfferBatch(
   });
 }
 
+export async function signMetaTxExtendOffer(
+  args: BaseMetaTxArgs & {
+    offerId: BigNumberish;
+    validUntil: BigNumberish;
+  }
+) {
+  return signMetaTx({
+    ...args,
+    functionName: "extendOffer(uint256,uint256)",
+    functionSignature: bosonOfferHandlerIface.encodeFunctionData(
+      "extendOffer",
+      [args.offerId, args.validUntil]
+    )
+  });
+}
+
+export async function signMetaTxExtendOfferBatch(
+  args: BaseMetaTxArgs & {
+    offerIds: BigNumberish[];
+    validUntil: BigNumberish;
+  }
+) {
+  return signMetaTx({
+    ...args,
+    functionName: "extendOfferBatch(uint256[],uint256)",
+    functionSignature: bosonOfferHandlerIface.encodeFunctionData(
+      "extendOfferBatch",
+      [args.offerIds, args.validUntil]
+    )
+  });
+}
+
 export async function signMetaTxCompleteExchangeBatch(
   args: BaseMetaTxArgs & {
     exchangeIds: BigNumberish[];
@@ -522,12 +615,13 @@ export async function signMetaTxReserveRange(
   args: BaseMetaTxArgs & {
     offerId: BigNumberish;
     length: BigNumberish;
+    to: string;
   }
 ) {
   return signMetaTx({
     ...args,
-    functionName: "reserveRange(uint256,uint256)",
-    functionSignature: encodeReserveRange(args.offerId, args.length)
+    functionName: "reserveRange(uint256,uint256,address)",
+    functionSignature: encodeReserveRange(args.offerId, args.length, args.to)
   });
 }
 
@@ -535,10 +629,12 @@ export async function signMetaTxPreMint(
   args: BaseVoucherMetaTxArgs & {
     offerId: BigNumberish;
     amount: BigNumberish;
-    batchId: BigNumberish;
+    batchId?: BigNumberish;
+    forwarderAddress?: string;
     forwarderAbi:
       | typeof abis.MockForwarderABI
       | typeof abis.BiconomyForwarderABI;
+    relayerUrl: string;
   }
 ): Promise<SignedVoucherMetaTx> {
   const localConfig = defaultConfigs.find(
@@ -549,13 +645,17 @@ export async function signMetaTxPreMint(
   if (isLocal) {
     return signVoucherMetaTx({
       ...args,
-      functionSignature
+      forwarderAddress: args.forwarderAddress,
+      functionSignature,
+      forwarderAbi: args.forwarderAbi as typeof abis.MockForwarderABI
     });
   }
   const txGas = 200000 + BigNumber.from(args.amount).mul(2500).toNumber(); // ~(180000 + 2250*N) estimation on 2023/02/03
   return signBiconomyVoucherMetaTx({
     ...args,
     functionSignature,
+    forwarderAbi: args.forwarderAbi as typeof abis.BiconomyForwarderABI,
+    batchId: args.batchId || "0",
     txGas
   });
 }
@@ -564,10 +664,12 @@ export async function signMetaTxSetApprovalForAll(
   args: BaseVoucherMetaTxArgs & {
     operator: string;
     approved: boolean;
-    batchId: BigNumberish;
+    batchId?: BigNumberish;
+    forwarderAddress?: string;
     forwarderAbi:
       | typeof abis.MockForwarderABI
       | typeof abis.BiconomyForwarderABI;
+    relayerUrl: string;
   }
 ): Promise<SignedVoucherMetaTx> {
   const localConfig = defaultConfigs.find(
@@ -581,13 +683,96 @@ export async function signMetaTxSetApprovalForAll(
   if (isLocal) {
     return signVoucherMetaTx({
       ...args,
-      functionSignature
+      forwarderAddress: args.forwarderAddress,
+      functionSignature,
+      forwarderAbi: args.forwarderAbi as typeof abis.MockForwarderABI
     });
   }
   const txGas = 100000; // ~70000 estimation on 2023/02/03
   return signBiconomyVoucherMetaTx({
     ...args,
     functionSignature,
+    forwarderAbi: args.forwarderAbi as typeof abis.BiconomyForwarderABI,
+    batchId: args.batchId || "0",
+    txGas
+  });
+}
+
+export async function signMetaTxSetApprovalForAllToContract(
+  args: BaseVoucherMetaTxArgs & {
+    operator: string;
+    approved: boolean;
+    batchId?: BigNumberish;
+    forwarderAddress?: string;
+    forwarderAbi:
+      | typeof abis.MockForwarderABI
+      | typeof abis.BiconomyForwarderABI;
+    relayerUrl: string;
+  },
+  overrides: {
+    txGas?: number;
+  } = {}
+): Promise<SignedVoucherMetaTx> {
+  const localConfig = defaultConfigs.find(
+    (config) => config.envName === "local"
+  );
+  const isLocal = localConfig.chainId === args.chainId;
+  const functionSignature = encodeSetApprovalForAllToContract(
+    args.operator,
+    args.approved
+  );
+  if (isLocal) {
+    return signVoucherMetaTx({
+      ...args,
+      forwarderAddress: args.forwarderAddress,
+      functionSignature,
+      forwarderAbi: args.forwarderAbi as typeof abis.MockForwarderABI
+    });
+  }
+  const txGas = overrides.txGas || 100000; // TODO: estimate the gas needed
+  return signBiconomyVoucherMetaTx({
+    ...args,
+    functionSignature,
+    forwarderAbi: args.forwarderAbi as typeof abis.BiconomyForwarderABI,
+    batchId: args.batchId || "0",
+    txGas
+  });
+}
+
+export async function signMetaTxCallExternalContract(
+  args: BaseVoucherMetaTxArgs & {
+    to: string;
+    data: string;
+    batchId?: BigNumberish;
+    forwarderAddress?: string;
+    forwarderAbi:
+      | typeof abis.MockForwarderABI
+      | typeof abis.BiconomyForwarderABI;
+    relayerUrl: string;
+  },
+  overrides: {
+    txGas?: number;
+  } = {}
+): Promise<SignedVoucherMetaTx> {
+  const localConfig = defaultConfigs.find(
+    (config) => config.envName === "local"
+  );
+  const isLocal = localConfig.chainId === args.chainId;
+  const functionSignature = encodeCallExternalContract(args.to, args.data);
+  if (isLocal) {
+    return signVoucherMetaTx({
+      ...args,
+      forwarderAddress: args.forwarderAddress,
+      functionSignature,
+      forwarderAbi: args.forwarderAbi as typeof abis.MockForwarderABI
+    });
+  }
+  const txGas = overrides.txGas || 500000; // TODO: estimate the gas needed
+  return signBiconomyVoucherMetaTx({
+    ...args,
+    functionSignature,
+    forwarderAbi: args.forwarderAbi as typeof abis.BiconomyForwarderABI,
+    batchId: args.batchId || "0",
     txGas
   });
 }