@bosonprotocol/core-sdk 1.24.1-alpha.0 → 1.24.1-alpha.2

package/src/meta-tx/handler.ts

@@ -44,6 +44,14 @@ export type BaseMetaTxArgs = {
   chainId: number;
 };
 
+export type BaseVoucherMetaTxArgs = {
+  web3Lib: Web3LibAdapter;
+  nonce: BigNumberish;
+  bosonVoucherAddress: string;
+  forwarderAddress: string;
+  chainId: number;
+};
+
 export type SignedMetaTx = {
   functionName: string;
   functionSignature: string;
@@ -95,6 +103,65 @@ export async function signMetaTx(
   };
 }
 
+export async function signVoucherMetaTx(
+  args: BaseVoucherMetaTxArgs & {
+    functionSignature: string;
+  }
+): Promise<{
+  to: string;
+  functionSignature: string;
+  r: string;
+  s: string;
+  v: number;
+}> {
+  const forwardType = [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "nonce", type: "uint256" },
+    { name: "data", type: "bytes" }
+  ];
+
+  const customSignatureType = {
+    EIP712Domain: [
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "chainId", type: "uint256" },
+      { name: "verifyingContract", type: "address" }
+    ],
+    ForwardRequest: forwardType
+  };
+
+  const signerAddress = await args.web3Lib.getSignerAddress();
+  const chainId = await args.web3Lib.getChainId();
+
+  const message = {
+    from: signerAddress,
+    to: args.bosonVoucherAddress,
+    nonce: args.nonce,
+    data: args.functionSignature
+  };
+
+  const signature = await prepareDataSignatureParameters({
+    ...args,
+    verifyingContractAddress: args.forwarderAddress,
+    customSignatureType,
+    primaryType: "ForwardRequest",
+    message,
+    customDomainData: {
+      name: "MockForwarder",
+      version: "0.0.1",
+      chainId,
+      salt: undefined
+    }
+  });
+
+  return {
+    to: message.to,
+    functionSignature: args.functionSignature,
+    ...signature
+  };
+}
+
 export async function signMetaTxCreateSeller(
   args: BaseMetaTxArgs & {
     createSellerArgs: CreateSellerArgs;
@@ -290,14 +357,13 @@ export async function signMetaTxReserveRange(
 }
 
 export async function signMetaTxPreMint(
-  args: BaseMetaTxArgs & {
+  args: BaseVoucherMetaTxArgs & {
     offerId: BigNumberish;
     amount: BigNumberish;
   }
 ) {
-  return signMetaTx({
+  return signVoucherMetaTx({
     ...args,
-    functionName: "preMint(uint256,uint256)",
     functionSignature: encodePreMint(args.offerId, args.amount)
   });
 }

package/src/meta-tx/mixin.ts

@@ -1,10 +1,12 @@
-import { MetaTxConfig, TransactionResponse } from "@bosonprotocol/common";
+import { abis, MetaTxConfig, TransactionResponse } from "@bosonprotocol/common";
 import { BigNumberish } from "@ethersproject/bignumber";
 import { BytesLike } from "@ethersproject/bytes";
 import { handler } from ".";
 import { getOfferById } from "../offers/subgraph";
 import { BaseCoreSDK } from "./../mixins/base-core-sdk";
 import { GetRetriedHashesData } from "./biconomy";
+import { Contract } from "ethers";
+import { getNonce } from "../forwarder/handler";
 export class MetaTxMixin extends BaseCoreSDK {
   /* -------------------------------------------------------------------------- */
   /*                           Meta Tx related methods                          */
@@ -154,17 +156,30 @@ export class MetaTxMixin extends BaseCoreSDK {
   public async signMetaTxPreMint(
     args: Omit<
       Parameters<typeof handler.signMetaTxPreMint>[0],
-      "web3Lib" | "metaTxHandlerAddress" | "chainId"
+      | "web3Lib"
+      | "bosonVoucherAddress"
+      | "chainId"
+      | "nonce"
+      | "forwarderAddress"
     >
   ) {
+    const signerAddress = await this._web3Lib.getSignerAddress();
+    const forwarderAddress = this._contracts.forwarder;
+    const nonce = await getNonce({
+      contractAddress: forwarderAddress,
+      user: signerAddress,
+      web3Lib: this._web3Lib
+    });
     const offerFromSubgraph = await getOfferById(
       this._subgraphUrl,
       args.offerId
     );
     return handler.signMetaTxPreMint({
       web3Lib: this._web3Lib,
-      metaTxHandlerAddress: offerFromSubgraph.seller.voucherCloneAddress,
+      bosonVoucherAddress: offerFromSubgraph.seller.voucherCloneAddress,
       chainId: this._chainId,
+      nonce,
+      forwarderAddress,
       ...args
     });
   }

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

@@ -2,7 +2,8 @@ import {
   Web3LibAdapter,
   MetadataStorage,
   MetaTxConfig,
-  LensContracts
+  LensContracts,
+  ContractAddresses
 } from "@bosonprotocol/common";
 import { TokenInfoManager } from "../utils/tokenInfoManager";
 
@@ -18,6 +19,7 @@ export class BaseCoreSDK {
 
   protected _metaTxConfig?: Partial<MetaTxConfig>;
   protected _lensContracts?: LensContracts;
+  protected _contracts?: ContractAddresses;
 
   /**
    * Creates an instance of `BaseCoreSDK`
@@ -32,6 +34,7 @@ export class BaseCoreSDK {
     chainId: number;
     metaTx?: Partial<MetaTxConfig>;
     lensContracts?: LensContracts;
+    contracts?: ContractAddresses;
   }) {
     this._web3Lib = opts.web3Lib;
     this._subgraphUrl = opts.subgraphUrl;
@@ -41,6 +44,7 @@ export class BaseCoreSDK {
     this._chainId = opts.chainId;
     this._metaTxConfig = opts.metaTx;
     this._lensContracts = opts.lensContracts;
+    this._contracts = opts.contracts;
   }
 
   protected assertAndGetMetaTxConfig(

package/src/utils/signature.ts

@@ -27,6 +27,11 @@ export async function prepareDataSignatureParameters(args: SignatureArgs) {
     salt: hexZeroPad(BigNumber.from(args.chainId).toHexString(), 32),
     ...args.customDomainData
   };
+  Object.keys(domainData).forEach((key) => {
+    if (domainData[key] === undefined) {
+      delete domainData[key];
+    }
+  });
 
   const signatureTypes = {
     EIP712Domain: domainType,

package/src/voucher/handler.ts

@@ -46,7 +46,6 @@ export async function getRangeByOfferId(args: {
   });
   const [range] = decodeGetRangeByOfferId(result);
   return {
-    offerId: range.offerId,
     start: range.start,
     length: range._length,
     minted: range.minted,