@bosonprotocol/core-sdk 1.25.0-alpha.2 → 1.25.0-alpha.21

package/src/meta-tx/handler.ts

@@ -30,18 +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 { ethers } from "ethers";
+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;
@@ -52,9 +65,7 @@ export type BaseMetaTxArgs = {
 
 export type BaseVoucherMetaTxArgs = {
   web3Lib: Web3LibAdapter;
-  nonce: BigNumberish;
   bosonVoucherAddress: string;
-  forwarderAddress: string;
   chainId: number;
 };
 
@@ -118,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 = [
@@ -140,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
   };
 
@@ -178,6 +197,7 @@ export async function signBiconomyVoucherMetaTx(
       | typeof abis.MockForwarderABI
       | typeof abis.BiconomyForwarderABI;
     txGas: BigNumberish;
+    relayerUrl: string;
   }
 ): Promise<SignedVoucherMetaTx> {
   const customSignatureType = {
@@ -205,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,
@@ -212,25 +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: ethers.utils.hexZeroPad(
-      ethers.BigNumber.from(chainId).toHexString(),
-      32
-    )
-  };
-
   const signatureParams = await prepareDataSignatureParameters({
     ...args,
     chainId,
-    verifyingContractAddress: args.forwarderAddress,
+    verifyingContractAddress: biconomyForwarderDomainData.verifyingContract,
     customSignatureType,
     primaryType: "ERC20ForwardRequest",
     message,
@@ -243,15 +290,15 @@ export async function signBiconomyVoucherMetaTx(
   const signature = signatureParams.signature;
   const getDomainSeparator = async () => {
     const domainData = biconomyForwarderDomainData;
-    const domainSeparator = ethers.utils.keccak256(
-      ethers.utils.defaultAbiCoder.encode(
+    const domainSeparator = keccak256(
+      defaultAbiCoder.encode(
         ["bytes32", "bytes32", "bytes32", "address", "bytes32"],
         [
-          ethers.utils.id(
+          id(
             "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
           ),
-          ethers.utils.id(domainData.name),
-          ethers.utils.id(domainData.version),
+          id(domainData.name),
+          id(domainData.version),
           domainData.verifyingContract,
           domainData.salt
         ]
@@ -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,
@@ -460,6 +507,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 +601,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 +615,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 +631,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 +650,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 +669,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
   });
 }

package/src/meta-tx/mixin.ts

@@ -142,14 +142,20 @@ export class MetaTxMixin extends BaseCoreSDK {
   public async signMetaTxReserveRange(
     args: Omit<
       Parameters<typeof handler.signMetaTxReserveRange>[0],
-      "web3Lib" | "metaTxHandlerAddress" | "chainId"
-    >
+      "web3Lib" | "metaTxHandlerAddress" | "chainId" | "to"
+    > & { to: "seller" | "contract" }
   ) {
+    const offer = await getOfferById(this._subgraphUrl, args.offerId);
+
     return handler.signMetaTxReserveRange({
       web3Lib: this._web3Lib,
       metaTxHandlerAddress: this._protocolDiamond,
       chainId: this._chainId,
-      ...args
+      ...args,
+      to:
+        args.to === "contract"
+          ? offer.seller.voucherCloneAddress
+          : offer.seller.assistant
     });
   }
 
@@ -159,25 +165,17 @@ export class MetaTxMixin extends BaseCoreSDK {
       | "web3Lib"
       | "bosonVoucherAddress"
       | "chainId"
-      | "nonce"
       | "forwarderAddress"
       | "batchId"
       | "forwarderAbi"
+      | "relayerUrl"
     >,
     overrides: Partial<{
       batchId: BigNumberish;
     }> = {}
   ) {
-    const signerAddress = await this._web3Lib.getSignerAddress();
     const forwarderAddress = this._contracts.forwarder;
     const batchId = overrides.batchId || 0;
-    const nonce = await getNonce({
-      contractAddress: forwarderAddress,
-      user: signerAddress,
-      web3Lib: this._web3Lib,
-      batchId,
-      forwarderAbi: this._metaTxConfig.forwarderAbi
-    });
     const offerFromSubgraph = await getOfferById(
       this._subgraphUrl,
       args.offerId
@@ -186,10 +184,10 @@ export class MetaTxMixin extends BaseCoreSDK {
       web3Lib: this._web3Lib,
       bosonVoucherAddress: offerFromSubgraph.seller.voucherCloneAddress,
       chainId: this._chainId,
-      nonce,
       forwarderAddress,
       batchId,
       forwarderAbi: this._metaTxConfig.forwarderAbi,
+      relayerUrl: this._metaTxConfig.relayerUrl,
       ...args
     });
   }
@@ -204,6 +202,7 @@ export class MetaTxMixin extends BaseCoreSDK {
       | "forwarderAddress"
       | "batchId"
       | "forwarderAbi"
+      | "relayerUrl"
     >,
     overrides: Partial<{
       batchId: BigNumberish;
@@ -216,26 +215,103 @@ export class MetaTxMixin extends BaseCoreSDK {
     );
     const forwarderAddress = this._contracts.forwarder;
     const batchId = overrides.batchId || 0;
-    const nonce = await getNonce({
-      contractAddress: forwarderAddress,
-      user: sellerAddress,
-      web3Lib: this._web3Lib,
-      batchId,
-      forwarderAbi: this._metaTxConfig.forwarderAbi
-    });
 
     return handler.signMetaTxSetApprovalForAll({
       web3Lib: this._web3Lib,
       bosonVoucherAddress: seller.voucherCloneAddress,
       chainId: this._chainId,
-      nonce,
       forwarderAddress,
       batchId,
       forwarderAbi: this._metaTxConfig.forwarderAbi,
+      relayerUrl: this._metaTxConfig.relayerUrl,
       ...args
     });
   }
 
+  public async signMetaTxSetApprovalForAllToContract(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxSetApprovalForAllToContract>[0],
+      | "web3Lib"
+      | "bosonVoucherAddress"
+      | "chainId"
+      | "nonce"
+      | "forwarderAddress"
+      | "batchId"
+      | "forwarderAbi"
+      | "relayerUrl"
+    >,
+    overrides: Partial<{
+      batchId?: BigNumberish;
+      txGas?: number;
+    }> = {}
+  ) {
+    const sellerAddress = await this._web3Lib.getSignerAddress();
+    const seller = await accounts.subgraph.getSellerByAddress(
+      this._subgraphUrl,
+      sellerAddress
+    );
+    const forwarderAddress = this._contracts.forwarder;
+    const batchId = overrides.batchId || 0;
+
+    return handler.signMetaTxSetApprovalForAllToContract(
+      {
+        web3Lib: this._web3Lib,
+        bosonVoucherAddress: seller.voucherCloneAddress,
+        chainId: this._chainId,
+        forwarderAddress,
+        batchId,
+        forwarderAbi: this._metaTxConfig.forwarderAbi,
+        relayerUrl: this._metaTxConfig.relayerUrl,
+        ...args
+      },
+      {
+        txGas: overrides.txGas
+      }
+    );
+  }
+
+  public async signMetaTxCallExternalContract(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxCallExternalContract>[0],
+      | "web3Lib"
+      | "bosonVoucherAddress"
+      | "chainId"
+      | "nonce"
+      | "forwarderAddress"
+      | "batchId"
+      | "forwarderAbi"
+      | "relayerUrl"
+    >,
+    overrides: Partial<{
+      batchId?: BigNumberish;
+      txGas?: number;
+    }> = {}
+  ) {
+    const sellerAddress = await this._web3Lib.getSignerAddress();
+    const seller = await accounts.subgraph.getSellerByAddress(
+      this._subgraphUrl,
+      sellerAddress
+    );
+    const forwarderAddress = this._contracts.forwarder;
+    const batchId = overrides.batchId || 0;
+
+    return handler.signMetaTxCallExternalContract(
+      {
+        web3Lib: this._web3Lib,
+        bosonVoucherAddress: seller.voucherCloneAddress,
+        chainId: this._chainId,
+        forwarderAddress,
+        batchId,
+        forwarderAbi: this._metaTxConfig.forwarderAbi,
+        relayerUrl: this._metaTxConfig.relayerUrl,
+        ...args
+      },
+      {
+        txGas: overrides.txGas
+      }
+    );
+  }
+
   public async relayBiconomyMetaTransaction(
     contractAddress: string,
     metaTxParams: {
@@ -340,6 +416,44 @@ export class MetaTxMixin extends BaseCoreSDK {
     });
   }
 
+  /**
+   * Encodes and signs a meta transaction for `extendOffer` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxExtendOffer(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxExtendOffer>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxExtendOffer({
+      web3Lib: this._web3Lib,
+      metaTxHandlerAddress: this._protocolDiamond,
+      chainId: this._chainId,
+      ...args
+    });
+  }
+
+  /**
+   * Encodes and signs a meta transaction for `extendOfferBatch` that can be relayed.
+   * @param args - Meta transaction args.
+   * @returns Signature.
+   */
+  public async signMetaTxExtendOfferBatch(
+    args: Omit<
+      Parameters<typeof handler.signMetaTxExtendOfferBatch>[0],
+      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+    >
+  ) {
+    return handler.signMetaTxExtendOfferBatch({
+      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.

package/src/metadata/base.graphql

@@ -39,6 +39,9 @@ fragment BaseBaseMetadataEntityFields on BaseMetadataEntity {
   description
   externalUrl
   animationUrl
+  animationMetadata {
+    ...BaseAnimationMetadataFields
+  }
   licenseUrl
   condition
   schemaUrl

package/src/metadata/product-v1.graphql

@@ -129,6 +129,9 @@ fragment BaseProductV1MetadataEntityFields on ProductV1MetadataEntity {
   description
   externalUrl
   animationUrl
+  animationMetadata {
+    ...BaseAnimationMetadataFields
+  }
   licenseUrl
   condition
   schemaUrl
@@ -173,6 +176,13 @@ fragment BaseProductV1MetadataEntityFields on ProductV1MetadataEntity {
   }
 }
 
+fragment BaseAnimationMetadataFields on AnimationMetadata {
+  id
+  width
+  height
+  type
+}
+
 fragment BaseProductV1ProductFields on ProductV1Product {
   id
   uuid
@@ -299,6 +309,8 @@ fragment BaseProductV1MediaFields on ProductV1Media {
   url
   tag
   type
+  width
+  height
 }
 
 fragment BaseProductV1PersonalisationFields on ProductV1Personalisation {