@bosonprotocol/core-sdk 1.47.0-alpha.3 → 1.47.0-alpha.5

package/dist/esm/meta-tx/handler.js

@@ -2,7 +2,7 @@ import { utils, envConfigs } from "@bosonprotocol/common";
 import { storeMetadataOnTheGraph } from "../offers/storage";
 import { BigNumber } from "@ethersproject/bignumber";
 import { encodeCreateSeller, encodeOptInToSellerUpdate, encodeUpdateSeller } from "../accounts/interface";
-import { bosonExchangeCommitHandlerIface, bosonExchangeHandlerIface, encodeCommitToBuyerOffer } from "../exchanges/interface";
+import { bosonExchangeCommitHandlerIface, bosonExchangeHandlerIface, encodeCommitToBuyerOffer, encodeCreateOfferAndCommit } from "../exchanges/interface";
 import { bosonOfferHandlerIface, encodeCreateOffer, encodeCreateOfferBatch, encodeReserveRange } from "../offers/interface";
 import { prepareDataSignatureParameters, rebuildSignature } from "../utils/signature";
 import { Biconomy } from "./biconomy";
@@ -20,6 +20,7 @@ import { getNonce, verifyEIP712 } from "../forwarder/handler";
 import { isTrustedForwarder } from "../voucher/handler";
 import { findCollectionSalt } from "../accounts/handler";
 import { storeMetadataItems } from "../metadata/storeMetadataItems";
+// Implementation
 export async function signMetaTx(args) {
     const metaTransactionType = [
         { name: "nonce", type: "uint256" },
@@ -33,12 +34,27 @@ export async function signMetaTx(args) {
     };
     const signerAddress = await args.web3Lib.getSignerAddress();
     const message = {
-        nonce: args.nonce,
+        nonce: args.nonce.toString(),
         from: signerAddress,
         contractAddress: args.metaTxHandlerAddress,
         functionName: args.functionName,
         functionSignature: args.functionSignature
     };
+    if (args.returnTypedDataToSign) {
+        const structuredData = await prepareDataSignatureParameters({
+            ...args,
+            verifyingContractAddress: args.metaTxHandlerAddress,
+            customSignatureType,
+            primaryType: "MetaTransaction",
+            message,
+            returnTypedDataToSign: true
+        });
+        return {
+            ...structuredData,
+            functionName: args.functionName,
+            functionSignature: args.functionSignature
+        };
+    }
     const signature = await prepareDataSignatureParameters({
         ...args,
         verifyingContractAddress: args.metaTxHandlerAddress,
@@ -251,6 +267,7 @@ export async function relayBiconomyMetaTransaction(args) {
         hash: relayTxResponse.txHash
     };
 }
+// Implementation
 export async function signMetaTxCreateSeller(args) {
     await Promise.all([args.createSellerArgs.contractUri, args.createSellerArgs.metadataUri].map((metadataUri) => storeMetadataOnTheGraph({
         metadataUriOrHash: metadataUri,
@@ -262,31 +279,46 @@ export async function signMetaTxCreateSeller(args) {
         contractAddress: args.metaTxHandlerAddress,
         ...args
     });
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "createSeller((uint256,address,address,address,address,bool,string),(uint256,uint8),(string,uint256,bytes32))",
         functionSignature: encodeCreateSeller(args.createSellerArgs, collectionSalt)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxUpdateSeller(args) {
     await storeMetadataOnTheGraph({
         metadataUriOrHash: args.updateSellerArgs.metadataUri,
         metadataStorage: args.metadataStorage,
         theGraphStorage: args.theGraphStorage
     });
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "updateSeller((uint256,address,address,address,address,bool,string),(uint256,uint8))",
         functionSignature: encodeUpdateSeller(args.updateSellerArgs)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxOptInToSellerUpdate(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "optInToSellerUpdate(uint256,uint8[])",
         functionSignature: encodeOptInToSellerUpdate(args.optInToSellerUpdateArgs)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxCreateOffer(args) {
     utils.validation.createOfferArgsSchema.validateSync(args.createOfferArgs, {
         abortEarly: false
@@ -300,12 +332,17 @@ export async function signMetaTxCreateOffer(args) {
         ...args,
         createOffersArgs: [args.createOfferArgs]
     });
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "createOffer((uint256,uint256,uint256,uint256,uint256,uint256,address,uint8,uint8,string,string,bool,uint256,(address[],uint256[])[],uint256),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),(uint256,address),uint256,uint256)",
         functionSignature: encodeCreateOffer(args.createOfferArgs)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxCreateOfferBatch(args) {
     for (const offerToCreate of args.createOffersArgs) {
         utils.validation.createOfferArgsSchema.validateSync(offerToCreate, {
@@ -318,76 +355,125 @@ export async function signMetaTxCreateOfferBatch(args) {
         theGraphStorage: args.theGraphStorage
     })));
     await storeMetadataItems(args);
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "createOfferBatch((uint256,uint256,uint256,uint256,uint256,uint256,address,uint8,uint8,string,string,bool,uint256,(address[],uint256[])[],uint256)[],(uint256,uint256,uint256,uint256)[],(uint256,uint256,uint256)[],(uint256,address)[],uint256[],uint256[])",
         functionSignature: encodeCreateOfferBatch(args.createOffersArgs)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxVoidOffer(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "voidOffer(uint256)",
         functionSignature: bosonOfferHandlerIface.encodeFunctionData("voidOffer", [
             args.offerId
         ])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxVoidOfferBatch(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "voidOfferBatch(uint256[])",
         functionSignature: bosonOfferHandlerIface.encodeFunctionData("voidOfferBatch", [args.offerIds])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxExtendOffer(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "extendOffer(uint256,uint256)",
         functionSignature: bosonOfferHandlerIface.encodeFunctionData("extendOffer", [args.offerId, args.validUntil])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxExtendOfferBatch(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "extendOfferBatch(uint256[],uint256)",
         functionSignature: bosonOfferHandlerIface.encodeFunctionData("extendOfferBatch", [args.offerIds, args.validUntil])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxCompleteExchangeBatch(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "completeExchangeBatch(uint256[])",
         functionSignature: bosonExchangeHandlerIface.encodeFunctionData("completeExchangeBatch", [args.exchangeIds])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxExpireVoucher(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "expireVoucher(uint256)",
         functionSignature: bosonExchangeHandlerIface.encodeFunctionData("expireVoucher", [args.exchangeId])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxRevokeVoucher(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "revokeVoucher(uint256)",
         functionSignature: bosonExchangeHandlerIface.encodeFunctionData("revokeVoucher", [args.exchangeId])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxCreateGroup(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "createGroup((uint256,uint256,uint256[]),(uint8,uint8,address,uint8,uint256,uint256,uint256,uint256))",
         functionSignature: encodeCreateGroup(args.createGroupArgs)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxReserveRange(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "reserveRange(uint256,uint256,address)",
         functionSignature: encodeReserveRange(args.offerId, args.length, args.to)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
 function isLocal(chainId) {
     const localConfigs = envConfigs["local"];
@@ -469,6 +555,7 @@ export async function signMetaTxCallExternalContract(args, overrides = {}) {
         txGas
     });
 }
+// Implementation
 export async function signMetaTxCreateOfferWithCondition(args) {
     utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
         abortEarly: false
@@ -482,12 +569,17 @@ export async function signMetaTxCreateOfferWithCondition(args) {
         ...args,
         createOffersArgs: [args.offerToCreate]
     });
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "createOfferWithCondition((uint256,uint256,uint256,uint256,uint256,uint256,address,uint8,uint8,string,string,bool,uint256,(address[],uint256[])[],uint256),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),(uint256,address),(uint8,uint8,address,uint8,uint256,uint256,uint256,uint256),uint256,uint256)",
         functionSignature: encodeCreateOfferWithCondition(args.offerToCreate, args.condition)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxCommitToOffer(args) {
     const functionName = "commitToOffer(address,uint256)";
     const offerType = [
@@ -516,6 +608,18 @@ export async function signMetaTxCommitToOffer(args) {
             offerId: args.offerId.toString()
         }
     };
+    const functionSignature = bosonExchangeCommitHandlerIface.encodeFunctionData("commitToOffer", [buyerAddress, args.offerId]);
+    if (args.returnTypedDataToSign) {
+        const structuredData = await prepareDataSignatureParameters({
+            ...args,
+            verifyingContractAddress: args.metaTxHandlerAddress,
+            customSignatureType,
+            primaryType: "MetaTxCommitToOffer",
+            message,
+            returnTypedDataToSign: true
+        });
+        return { ...structuredData, functionName, functionSignature };
+    }
     const signatureParams = await prepareDataSignatureParameters({
         ...args,
         verifyingContractAddress: args.metaTxHandlerAddress,
@@ -527,9 +631,10 @@ export async function signMetaTxCommitToOffer(args) {
     return {
         ...signatureParams,
         functionName,
-        functionSignature: bosonExchangeCommitHandlerIface.encodeFunctionData("commitToOffer", [buyerAddress, args.offerId])
+        functionSignature
     };
 }
+// Implementation
 export async function signMetaTxCommitToConditionalOffer(args) {
     const functionName = "commitToConditionalOffer(address,uint256,uint256)";
     const offerType = [
@@ -560,6 +665,18 @@ export async function signMetaTxCommitToConditionalOffer(args) {
             tokenId: args.tokenId.toString()
         }
     };
+    const functionSignature = bosonExchangeCommitHandlerIface.encodeFunctionData("commitToConditionalOffer", [buyerAddress, args.offerId, args.tokenId]);
+    if (args.returnTypedDataToSign) {
+        const structuredData = await prepareDataSignatureParameters({
+            ...args,
+            verifyingContractAddress: args.metaTxHandlerAddress,
+            customSignatureType,
+            primaryType: "MetaTxCommitToConditionalOffer",
+            message,
+            returnTypedDataToSign: true
+        });
+        return { ...structuredData, functionName, functionSignature };
+    }
     const signatureParams = await prepareDataSignatureParameters({
         ...args,
         verifyingContractAddress: args.metaTxHandlerAddress,
@@ -571,35 +688,69 @@ export async function signMetaTxCommitToConditionalOffer(args) {
     return {
         ...signatureParams,
         functionName,
-        functionSignature: bosonExchangeCommitHandlerIface.encodeFunctionData("commitToConditionalOffer", [buyerAddress, args.offerId, args.tokenId])
+        functionSignature
     };
 }
+// Implementation
 export async function signMetaTxCommitToBuyerOffer(args) {
     const functionName = "commitToBuyerOffer(uint256,(uint256,(address[],uint256[]),address))";
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName,
         functionSignature: encodeCommitToBuyerOffer(args.offerId, args.sellerParams)
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
+}
+// Implementation
+export async function signMetaTxCreateOfferAndCommit(args) {
+    utils.validation.createOfferAndCommitArgsSchema.validateSync(args.createOfferAndCommitArgs, { abortEarly: false });
+    await storeMetadataOnTheGraph({
+        metadataUriOrHash: args.createOfferAndCommitArgs.metadataUri,
+        metadataStorage: args.metadataStorage,
+        theGraphStorage: args.theGraphStorage
+    });
+    await storeMetadataItems({
+        ...args,
+        createOffersArgs: [args.createOfferAndCommitArgs]
     });
+    const signMetaTxArgs = {
+        ...args,
+        functionName: "createOfferAndCommit(((uint256,uint256,uint256,uint256,uint256,uint256,address,uint8,uint8,string,string,bool,uint256,(address[],uint256[])[],uint256),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),(uint256,address),(uint8,uint8,address,uint8,uint256,uint256,uint256,uint256),uint256,uint256,bool),address,address,bytes,uint256,(uint256,(address[],uint256[]),address))",
+        functionSignature: encodeCreateOfferAndCommit(args.createOfferAndCommitArgs)
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxCancelVoucher(args) {
     return makeExchangeMetaTxSigner("cancelVoucher(uint256)")(args);
 }
+// Implementation
 export async function signMetaTxRedeemVoucher(args) {
     return makeExchangeMetaTxSigner("redeemVoucher(uint256)")(args);
 }
+// Implementation
 export async function signMetaTxCompleteExchange(args) {
     return makeExchangeMetaTxSigner("completeExchange(uint256)")(args);
 }
+// Implementation
 export async function signMetaTxRetractDispute(args) {
     return makeExchangeMetaTxSigner("retractDispute(uint256)", bosonDisputeHandlerIface)(args);
 }
+// Implementation
 export async function signMetaTxEscalateDispute(args) {
     return makeExchangeMetaTxSigner("escalateDispute(uint256)", bosonDisputeHandlerIface)(args);
 }
+// Implementation
 export async function signMetaTxRaiseDispute(args) {
     return makeExchangeMetaTxSigner("raiseDispute(uint256)", bosonDisputeHandlerIface)(args);
 }
+// Implementation
 export async function signMetaTxResolveDispute(args) {
     const functionName = "resolveDispute(uint256,uint256,bytes)";
     const counterpartySig = typeof args.counterpartySig === "string"
@@ -632,6 +783,20 @@ export async function signMetaTxResolveDispute(args) {
             signature: counterpartySig
         }
     };
+    const functionSignature = bosonDisputeHandlerIface.encodeFunctionData(
+    // remove params in brackets from string
+    functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [args.exchangeId, args.buyerPercent, counterpartySig]);
+    if (args.returnTypedDataToSign) {
+        const structuredData = await prepareDataSignatureParameters({
+            ...args,
+            verifyingContractAddress: args.metaTxHandlerAddress,
+            customSignatureType,
+            primaryType: "MetaTxDisputeResolution",
+            message,
+            returnTypedDataToSign: true
+        });
+        return { ...structuredData, functionName, functionSignature };
+    }
     const signatureParams = await prepareDataSignatureParameters({
         ...args,
         verifyingContractAddress: args.metaTxHandlerAddress,
@@ -643,18 +808,22 @@ export async function signMetaTxResolveDispute(args) {
     return {
         ...signatureParams,
         functionName,
-        functionSignature: bosonDisputeHandlerIface.encodeFunctionData(
-        // remove params in brackets from string
-        functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [args.exchangeId, args.buyerPercent, counterpartySig])
+        functionSignature
     };
 }
+// Implementation
 export async function signMetaTxExtendDisputeTimeout(args) {
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "extendDisputeTimeout(uint256,uint256)",
         functionSignature: bosonDisputeHandlerIface.encodeFunctionData("extendDisputeTimeout", [args.exchangeId, args.newTimeout])
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
+// Implementation
 export async function signMetaTxWithdrawFunds(args) {
     const functionName = "withdrawFunds(uint256,address[],uint256[])";
     const fundType = [
@@ -684,6 +853,18 @@ export async function signMetaTxWithdrawFunds(args) {
             tokenAmounts: args.tokenAmounts.map((bn) => bn.toString())
         }
     };
+    const functionSignature = encodeWithdrawFunds(args.entityId, args.tokenList, args.tokenAmounts);
+    if (args.returnTypedDataToSign) {
+        const structuredData = await prepareDataSignatureParameters({
+            ...args,
+            verifyingContractAddress: args.metaTxHandlerAddress,
+            customSignatureType,
+            primaryType: "MetaTxFund",
+            message,
+            returnTypedDataToSign: true
+        });
+        return { ...structuredData, functionName, functionSignature };
+    }
     const signatureParams = await prepareDataSignatureParameters({
         ...args,
         verifyingContractAddress: args.metaTxHandlerAddress,
@@ -695,9 +876,10 @@ export async function signMetaTxWithdrawFunds(args) {
     return {
         ...signatureParams,
         functionName,
-        functionSignature: encodeWithdrawFunds(args.entityId, args.tokenList, args.tokenAmounts)
+        functionSignature
     };
 }
+// Implementation
 export async function signMetaTxDepositFunds(args) {
     if (!isAddress(args.fundsTokenAddress)) {
         throw new Error(`Invalid fundsTokenAddress: ${args.fundsTokenAddress}`);
@@ -705,11 +887,15 @@ export async function signMetaTxDepositFunds(args) {
     if (args.fundsTokenAddress === AddressZero) {
         throw new Error(`Meta transaction can't be used to deposit native currency`);
     }
-    return signMetaTx({
+    const signMetaTxArgs = {
         ...args,
         functionName: "depositFunds(uint256,address,uint256)",
         functionSignature: encodeDepositFunds(args.entityId, args.fundsTokenAddress, args.fundsAmount)
-    });
+    };
+    if (args.returnTypedDataToSign) {
+        return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: true });
+    }
+    return signMetaTx({ ...signMetaTxArgs, returnTypedDataToSign: false });
 }
 function makeExchangeMetaTxSigner(functionName, handlerIface = bosonExchangeHandlerIface) {
     return async function signExchangeMetaTx(args) {
@@ -735,6 +921,20 @@ function makeExchangeMetaTxSigner(functionName, handlerIface = bosonExchangeHand
                 exchangeId: args.exchangeId.toString()
             }
         };
+        const functionSignature = handlerIface.encodeFunctionData(
+        // remove params in brackets from string
+        functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [args.exchangeId]);
+        if (args.returnTypedDataToSign) {
+            const structuredData = await prepareDataSignatureParameters({
+                ...args,
+                verifyingContractAddress: args.metaTxHandlerAddress,
+                customSignatureType,
+                primaryType: "MetaTxExchange",
+                message,
+                returnTypedDataToSign: true
+            });
+            return { ...structuredData, functionName, functionSignature };
+        }
         const signatureParams = await prepareDataSignatureParameters({
             ...args,
             verifyingContractAddress: args.metaTxHandlerAddress,
@@ -746,9 +946,7 @@ function makeExchangeMetaTxSigner(functionName, handlerIface = bosonExchangeHand
         return {
             ...signatureParams,
             functionName,
-            functionSignature: handlerIface.encodeFunctionData(
-            // remove params in brackets from string
-            functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [args.exchangeId])
+            functionSignature
         };
     };
 }