@bosonprotocol/core-sdk 1.29.0-ludo.1 → 1.29.0

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

@@ -1,734 +1,734 @@
-import { utils, defaultConfigs } from "@bosonprotocol/common";
-import { storeMetadataOnTheGraph } from "../offers/storage";
-import { BigNumber } from "@ethersproject/bignumber";
-import { encodeCreateSeller, encodeOptInToSellerUpdate, encodeUpdateSeller } from "../accounts/interface";
-import { bosonExchangeHandlerIface } from "../exchanges/interface";
-import { bosonOfferHandlerIface, encodeCreateOffer, encodeCreateOfferBatch, encodeReserveRange } from "../offers/interface";
-import { prepareDataSignatureParameters } from "../utils/signature";
-import { Biconomy } 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 { encodeCallExternalContract, encodePreMint, encodeSetApprovalForAll, encodeSetApprovalForAllToContract } from "../voucher/interface";
-import { keccak256 } from "@ethersproject/keccak256";
-import { id } from "@ethersproject/hash";
-import { defaultAbiCoder } from "@ethersproject/abi";
-import { getNonce, verifyEIP712 } from "../forwarder/handler";
-import { isTrustedForwarder } from "../voucher/handler";
-export async function signMetaTx(args) {
-    const metaTransactionType = [
-        { name: "nonce", type: "uint256" },
-        { name: "from", type: "address" },
-        { name: "contractAddress", type: "address" },
-        { name: "functionName", type: "string" },
-        { name: "functionSignature", type: "bytes" }
-    ];
-    const customSignatureType = {
-        MetaTransaction: metaTransactionType
-    };
-    const signerAddress = await args.web3Lib.getSignerAddress();
-    const message = {
-        nonce: args.nonce,
-        from: signerAddress,
-        contractAddress: args.metaTxHandlerAddress,
-        functionName: args.functionName,
-        functionSignature: args.functionSignature
-    };
-    const signature = await prepareDataSignatureParameters({
-        ...args,
-        verifyingContractAddress: args.metaTxHandlerAddress,
-        customSignatureType,
-        primaryType: "MetaTransaction",
-        message
-    });
-    return {
-        functionName: args.functionName,
-        functionSignature: args.functionSignature,
-        ...signature
-    };
-}
-export async function signVoucherMetaTx(args) {
-    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 nonce = await getNonce({
-        contractAddress: args.forwarderAddress,
-        user: signerAddress,
-        web3Lib: args.web3Lib,
-        forwarderAbi: args.forwarderAbi
-    });
-    const message = {
-        from: signerAddress,
-        to: args.bosonVoucherAddress,
-        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,
-        request: message,
-        ...signature
-    };
-}
-export async function signBiconomyVoucherMetaTx(args) {
-    const customSignatureType = {
-        EIP712Domain: [
-            { name: "name", type: "string" },
-            { name: "version", type: "string" },
-            // { name: "chainId", type: "uint256" },
-            // { name: "verifyingContract", type: "address" }
-            { name: "verifyingContract", type: "address" },
-            { name: "salt", type: "bytes32" }
-        ],
-        ERC20ForwardRequest: [
-            { name: "from", type: "address" },
-            { name: "to", type: "address" },
-            { name: "token", type: "address" },
-            { name: "txGas", type: "uint256" },
-            { name: "tokenGasPrice", type: "uint256" },
-            { name: "batchId", type: "uint256" },
-            { name: "batchNonce", type: "uint256" },
-            { name: "deadline", type: "uint256" },
-            { name: "data", type: "bytes" }
-        ]
-    };
-    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(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,
-        token: "0x0000000000000000000000000000000000000000",
-        txGas: args.txGas,
-        tokenGasPrice: "0",
-        batchId: args.batchId,
-        batchNonce: nonce,
-        deadline: Math.floor(Date.now() / 1000 + 3600),
-        data: args.functionSignature
-    };
-    const signatureParams = await prepareDataSignatureParameters({
-        ...args,
-        chainId,
-        verifyingContractAddress: biconomyForwarderDomainData.verifyingContract,
-        customSignatureType,
-        primaryType: "ERC20ForwardRequest",
-        message,
-        customDomainData: {
-            ...biconomyForwarderDomainData
-            // chainId
-            // salt: undefined
-        }
-    });
-    const signature = signatureParams.signature;
-    const getDomainSeparator = async () => {
-        const domainData = biconomyForwarderDomainData;
-        const domainSeparator = keccak256(defaultAbiCoder.encode(["bytes32", "bytes32", "bytes32", "address", "bytes32"], [
-            id("EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"),
-            id(domainData.name),
-            id(domainData.version),
-            domainData.verifyingContract,
-            domainData.salt
-        ]));
-        return domainSeparator;
-    };
-    const domainSeparator = await getDomainSeparator();
-    // verify signature
-    const signatureVerified = await verifyEIP712({
-        request: message,
-        contractAddress: biconomyForwarderDomainData.verifyingContract,
-        web3Lib: args.web3Lib,
-        domainSeparator,
-        forwarderAbi: args.forwarderAbi,
-        signature
-    });
-    if (!signatureVerified) {
-        throw `Signature is not verified`;
-    }
-    return {
-        to: message.to,
-        domainSeparator,
-        request: message,
-        ...signatureParams,
-        signature,
-        functionSignature: args.functionSignature
-    };
-}
-export async function relayBiconomyMetaTransaction(args) {
-    const { chainId, contractAddress, metaTx } = args;
-    const biconomy = new Biconomy(metaTx.config.relayerUrl, metaTx.config.apiKey, metaTx.config.apiId);
-    const relayTxResponse = await biconomy.relayTransaction({
-        to: contractAddress,
-        params: [
-            metaTx.params.request,
-            metaTx.params.domainSeparator,
-            metaTx.params.signature
-        ],
-        from: metaTx.params.userAddress,
-        signatureType: "EIP712_SIGN"
-    });
-    return {
-        wait: async () => {
-            const waitResponse = await biconomy.wait({
-                networkId: chainId,
-                transactionHash: relayTxResponse.txHash
-            });
-            const txHash = waitResponse.data.newHash;
-            const txReceipt = await args.web3LibAdapter.getTransactionReceipt(txHash);
-            return {
-                to: txReceipt?.to || contractAddress,
-                from: txReceipt?.from || metaTx.params.userAddress,
-                transactionHash: txHash,
-                logs: txReceipt?.logs || [],
-                effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice)
-            };
-        },
-        hash: relayTxResponse.txHash
-    };
-}
-export async function signMetaTxCreateSeller(args) {
-    await storeMetadataOnTheGraph({
-        metadataUriOrHash: args.createSellerArgs.metadataUri,
-        metadataStorage: args.metadataStorage,
-        theGraphStorage: args.theGraphStorage
-    });
-    return signMetaTx({
-        ...args,
-        functionName: "createSeller((uint256,address,address,address,address,bool,string),(uint256,uint8),(string,uint256))",
-        functionSignature: encodeCreateSeller(args.createSellerArgs)
-    });
-}
-export async function signMetaTxUpdateSeller(args) {
-    await storeMetadataOnTheGraph({
-        metadataUriOrHash: args.updateSellerArgs.metadataUri,
-        metadataStorage: args.metadataStorage,
-        theGraphStorage: args.theGraphStorage
-    });
-    return signMetaTx({
-        ...args,
-        functionName: "updateSeller((uint256,address,address,address,address,bool,string),(uint256,uint8))",
-        functionSignature: encodeUpdateSeller(args.updateSellerArgs)
-    });
-}
-export async function signMetaTxOptInToSellerUpdate(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "optInToSellerUpdate(uint256,uint8[])",
-        functionSignature: encodeOptInToSellerUpdate(args.optInToSellerUpdateArgs)
-    });
-}
-export async function signMetaTxCreateOffer(args) {
-    utils.validation.createOfferArgsSchema.validateSync(args.createOfferArgs, {
-        abortEarly: false
-    });
-    await storeMetadataOnTheGraph({
-        metadataUriOrHash: args.createOfferArgs.metadataUri,
-        metadataStorage: args.metadataStorage,
-        theGraphStorage: args.theGraphStorage
-    });
-    return signMetaTx({
-        ...args,
-        functionName: "createOffer((uint256,uint256,uint256,uint256,uint256,uint256,address,string,string,bool),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),uint256,uint256)",
-        functionSignature: encodeCreateOffer(args.createOfferArgs)
-    });
-}
-export async function signMetaTxCreateOfferBatch(args) {
-    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: "createOfferBatch((uint256,uint256,uint256,uint256,uint256,uint256,address,string,string,bool)[],(uint256,uint256,uint256,uint256)[],(uint256,uint256,uint256)[],uint256[],uint256[])",
-        functionSignature: encodeCreateOfferBatch(args.createOffersArgs)
-    });
-}
-export async function signMetaTxVoidOffer(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "voidOffer(uint256)",
-        functionSignature: bosonOfferHandlerIface.encodeFunctionData("voidOffer", [
-            args.offerId
-        ])
-    });
-}
-export async function signMetaTxVoidOfferBatch(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "voidOfferBatch(uint256[])",
-        functionSignature: bosonOfferHandlerIface.encodeFunctionData("voidOfferBatch", [args.offerIds])
-    });
-}
-export async function signMetaTxExtendOffer(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "extendOffer(uint256,uint256)",
-        functionSignature: bosonOfferHandlerIface.encodeFunctionData("extendOffer", [args.offerId, args.validUntil])
-    });
-}
-export async function signMetaTxExtendOfferBatch(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "extendOfferBatch(uint256[],uint256)",
-        functionSignature: bosonOfferHandlerIface.encodeFunctionData("extendOfferBatch", [args.offerIds, args.validUntil])
-    });
-}
-export async function signMetaTxCompleteExchangeBatch(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "completeExchangeBatch(uint256[])",
-        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("completeExchangeBatch", [args.exchangeIds])
-    });
-}
-export async function signMetaTxExpireVoucher(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "expireVoucher(uint256)",
-        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("expireVoucher", [args.exchangeId])
-    });
-}
-export async function signMetaTxRevokeVoucher(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "revokeVoucher(uint256)",
-        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("revokeVoucher", [args.exchangeId])
-    });
-}
-export async function signMetaTxCreateGroup(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "createGroup((uint256,uint256,uint256[]),(uint8,uint8,address,uint256,uint256,uint256))",
-        functionSignature: encodeCreateGroup(args.createGroupArgs)
-    });
-}
-export async function signMetaTxReserveRange(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "reserveRange(uint256,uint256,address)",
-        functionSignature: encodeReserveRange(args.offerId, args.length, args.to)
-    });
-}
-export async function signMetaTxPreMint(args) {
-    const localConfig = defaultConfigs.find((config) => config.envName === "local");
-    const isLocal = localConfig.chainId === args.chainId;
-    const functionSignature = encodePreMint(args.offerId, args.amount);
-    if (isLocal) {
-        return signVoucherMetaTx({
-            ...args,
-            forwarderAddress: args.forwarderAddress,
-            functionSignature,
-            forwarderAbi: args.forwarderAbi
-        });
-    }
-    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,
-        batchId: args.batchId || "0",
-        txGas
-    });
-}
-export async function signMetaTxSetApprovalForAll(args) {
-    const localConfig = defaultConfigs.find((config) => config.envName === "local");
-    const isLocal = localConfig.chainId === args.chainId;
-    const functionSignature = encodeSetApprovalForAll(args.operator, args.approved);
-    if (isLocal) {
-        return signVoucherMetaTx({
-            ...args,
-            forwarderAddress: args.forwarderAddress,
-            functionSignature,
-            forwarderAbi: args.forwarderAbi
-        });
-    }
-    const txGas = 100000; // ~70000 estimation on 2023/02/03
-    return signBiconomyVoucherMetaTx({
-        ...args,
-        functionSignature,
-        forwarderAbi: args.forwarderAbi,
-        batchId: args.batchId || "0",
-        txGas
-    });
-}
-export async function signMetaTxSetApprovalForAllToContract(args, overrides = {}) {
-    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
-        });
-    }
-    const txGas = overrides.txGas || 100000; // TODO: estimate the gas needed
-    return signBiconomyVoucherMetaTx({
-        ...args,
-        functionSignature,
-        forwarderAbi: args.forwarderAbi,
-        batchId: args.batchId || "0",
-        txGas
-    });
-}
-export async function signMetaTxCallExternalContract(args, overrides = {}) {
-    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
-        });
-    }
-    const txGas = overrides.txGas || 500000; // TODO: estimate the gas needed
-    return signBiconomyVoucherMetaTx({
-        ...args,
-        functionSignature,
-        forwarderAbi: args.forwarderAbi,
-        batchId: args.batchId || "0",
-        txGas
-    });
-}
-export async function signMetaTxCreateOfferWithCondition(args) {
-    utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
-        abortEarly: false
-    });
-    await storeMetadataOnTheGraph({
-        metadataUriOrHash: args.offerToCreate.metadataUri,
-        metadataStorage: args.metadataStorage,
-        theGraphStorage: args.theGraphStorage
-    });
-    return signMetaTx({
-        ...args,
-        functionName: "createOfferWithCondition((uint256,uint256,uint256,uint256,uint256,uint256,address,string,string,bool),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),uint256,(uint8,uint8,address,uint256,uint256,uint256),uint256)",
-        functionSignature: encodeCreateOfferWithCondition(args.offerToCreate, args.condition)
-    });
-}
-export async function signMetaTxCommitToOffer(args) {
-    const functionName = "commitToOffer(address,uint256)";
-    const offerType = [
-        { name: "buyer", type: "address" },
-        { name: "offerId", type: "uint256" }
-    ];
-    const metaTransactionType = [
-        { name: "nonce", type: "uint256" },
-        { name: "from", type: "address" },
-        { name: "contractAddress", type: "address" },
-        { name: "functionName", type: "string" },
-        { name: "offerDetails", type: "MetaTxOfferDetails" }
-    ];
-    const customSignatureType = {
-        MetaTxCommitToOffer: metaTransactionType,
-        MetaTxOfferDetails: offerType
-    };
-    const buyerAddress = await args.web3Lib.getSignerAddress();
-    const message = {
-        nonce: args.nonce.toString(),
-        from: buyerAddress,
-        contractAddress: args.metaTxHandlerAddress,
-        functionName,
-        offerDetails: {
-            buyer: buyerAddress,
-            offerId: args.offerId.toString()
-        }
-    };
-    const signatureParams = await prepareDataSignatureParameters({
-        ...args,
-        verifyingContractAddress: args.metaTxHandlerAddress,
-        customSignatureType,
-        primaryType: "MetaTxCommitToOffer",
-        message
-    });
-    return {
-        ...signatureParams,
-        functionName,
-        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("commitToOffer", [buyerAddress, args.offerId])
-    };
-}
-export async function signMetaTxCancelVoucher(args) {
-    return makeExchangeMetaTxSigner("cancelVoucher(uint256)")(args);
-}
-export async function signMetaTxRedeemVoucher(args) {
-    return makeExchangeMetaTxSigner("redeemVoucher(uint256)")(args);
-}
-export async function signMetaTxCompleteExchange(args) {
-    return makeExchangeMetaTxSigner("completeExchange(uint256)")(args);
-}
-export async function signMetaTxRetractDispute(args) {
-    return makeExchangeMetaTxSigner("retractDispute(uint256)", bosonDisputeHandlerIface)(args);
-}
-export async function signMetaTxEscalateDispute(args) {
-    return makeExchangeMetaTxSigner("escalateDispute(uint256)", bosonDisputeHandlerIface)(args);
-}
-export async function signMetaTxRaiseDispute(args) {
-    return makeExchangeMetaTxSigner("raiseDispute(uint256)", bosonDisputeHandlerIface)(args);
-}
-export async function signMetaTxResolveDispute(args) {
-    const functionName = "resolveDispute(uint256,uint256,bytes32,bytes32,uint8)";
-    const disputeResolutionType = [
-        { name: "exchangeId", type: "uint256" },
-        { name: "buyerPercentBasisPoints", type: "uint256" },
-        { name: "sigR", type: "bytes32" },
-        { name: "sigS", type: "bytes32" },
-        { name: "sigV", type: "uint8" }
-    ];
-    const metaTransactionType = [
-        { name: "nonce", type: "uint256" },
-        { name: "from", type: "address" },
-        { name: "contractAddress", type: "address" },
-        { name: "functionName", type: "string" },
-        { name: "disputeResolutionDetails", type: "MetaTxDisputeResolutionDetails" }
-    ];
-    const customSignatureType = {
-        MetaTxDisputeResolution: metaTransactionType,
-        MetaTxDisputeResolutionDetails: disputeResolutionType
-    };
-    const message = {
-        nonce: args.nonce.toString(),
-        from: await args.web3Lib.getSignerAddress(),
-        contractAddress: args.metaTxHandlerAddress,
-        functionName,
-        disputeResolutionDetails: {
-            exchangeId: args.exchangeId.toString(),
-            buyerPercentBasisPoints: args.buyerPercent.toString(),
-            sigR: args.counterpartySig.r,
-            sigS: args.counterpartySig.s,
-            sigV: args.counterpartySig.v
-        }
-    };
-    const signatureParams = await prepareDataSignatureParameters({
-        ...args,
-        verifyingContractAddress: args.metaTxHandlerAddress,
-        customSignatureType,
-        primaryType: "MetaTxDisputeResolution",
-        message
-    });
-    return {
-        ...signatureParams,
-        functionName,
-        functionSignature: bosonDisputeHandlerIface.encodeFunctionData(
-        // remove params in brackets from string
-        functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [
-            args.exchangeId,
-            args.buyerPercent,
-            args.counterpartySig.r,
-            args.counterpartySig.s,
-            args.counterpartySig.v
-        ])
-    };
-}
-export async function signMetaTxExtendDisputeTimeout(args) {
-    return signMetaTx({
-        ...args,
-        functionName: "extendDisputeTimeout(uint256,uint256)",
-        functionSignature: bosonDisputeHandlerIface.encodeFunctionData("extendDisputeTimeout", [args.exchangeId, args.newTimeout])
-    });
-}
-export async function signMetaTxWithdrawFunds(args) {
-    const functionName = "withdrawFunds(uint256,address[],uint256[])";
-    const fundType = [
-        { name: "entityId", type: "uint256" },
-        { name: "tokenList", type: "address[]" },
-        { name: "tokenAmounts", type: "uint256[]" }
-    ];
-    const metaTransactionType = [
-        { name: "nonce", type: "uint256" },
-        { name: "from", type: "address" },
-        { name: "contractAddress", type: "address" },
-        { name: "functionName", type: "string" },
-        { name: "fundDetails", type: "MetaTxFundDetails" }
-    ];
-    const customSignatureType = {
-        MetaTxFund: metaTransactionType,
-        MetaTxFundDetails: fundType
-    };
-    const message = {
-        nonce: args.nonce.toString(),
-        from: await args.web3Lib.getSignerAddress(),
-        contractAddress: args.metaTxHandlerAddress,
-        functionName,
-        fundDetails: {
-            entityId: args.entityId.toString(),
-            tokenList: args.tokenList,
-            tokenAmounts: args.tokenAmounts.map((bn) => bn.toString())
-        }
-    };
-    const signatureParams = await prepareDataSignatureParameters({
-        ...args,
-        verifyingContractAddress: args.metaTxHandlerAddress,
-        customSignatureType,
-        primaryType: "MetaTxFund",
-        message
-    });
-    return {
-        ...signatureParams,
-        functionName,
-        functionSignature: encodeWithdrawFunds(args.entityId, args.tokenList, args.tokenAmounts)
-    };
-}
-export async function signMetaTxDepositFunds(args) {
-    if (!isAddress(args.fundsTokenAddress)) {
-        throw new Error(`Invalid fundsTokenAddress: ${args.fundsTokenAddress}`);
-    }
-    if (args.fundsTokenAddress === AddressZero) {
-        throw new Error(`Meta transaction can't be used to deposit native currency`);
-    }
-    return signMetaTx({
-        ...args,
-        functionName: "depositFunds(uint256,address,uint256)",
-        functionSignature: encodeDepositFunds(args.sellerId, args.fundsTokenAddress, args.fundsAmount)
-    });
-}
-function makeExchangeMetaTxSigner(functionName, handlerIface = bosonExchangeHandlerIface) {
-    return async function signExchangeMetaTx(args) {
-        const exchangeType = [{ name: "exchangeId", type: "uint256" }];
-        const metaTransactionType = [
-            { name: "nonce", type: "uint256" },
-            { name: "from", type: "address" },
-            { name: "contractAddress", type: "address" },
-            { name: "functionName", type: "string" },
-            { name: "exchangeDetails", type: "MetaTxExchangeDetails" }
-        ];
-        const customSignatureType = {
-            MetaTxExchange: metaTransactionType,
-            MetaTxExchangeDetails: exchangeType
-        };
-        const buyerAddress = await args.web3Lib.getSignerAddress();
-        const message = {
-            nonce: args.nonce.toString(),
-            from: buyerAddress,
-            contractAddress: args.metaTxHandlerAddress,
-            functionName,
-            exchangeDetails: {
-                exchangeId: args.exchangeId.toString()
-            }
-        };
-        const signatureParams = await prepareDataSignatureParameters({
-            ...args,
-            verifyingContractAddress: args.metaTxHandlerAddress,
-            customSignatureType,
-            primaryType: "MetaTxExchange",
-            message
-        });
-        return {
-            ...signatureParams,
-            functionName,
-            functionSignature: handlerIface.encodeFunctionData(
-            // remove params in brackets from string
-            functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [args.exchangeId])
-        };
-    };
-}
-export async function relayMetaTransaction(args) {
-    const { chainId, contractAddress, metaTx } = args;
-    const biconomy = new Biconomy(metaTx.config.relayerUrl, metaTx.config.apiKey, metaTx.config.apiId);
-    const relayTxResponse = await biconomy.relayTransaction({
-        to: contractAddress,
-        params: [
-            metaTx.params.userAddress,
-            metaTx.params.functionName,
-            metaTx.params.functionSignature,
-            metaTx.params.nonce,
-            metaTx.params.sigR,
-            metaTx.params.sigS,
-            metaTx.params.sigV
-        ],
-        from: metaTx.params.userAddress
-    });
-    return {
-        wait: async () => {
-            const waitResponse = await biconomy.wait({
-                networkId: chainId,
-                transactionHash: relayTxResponse.txHash
-            });
-            const txHash = waitResponse.data.newHash;
-            const txReceipt = await args.web3LibAdapter.getTransactionReceipt(txHash);
-            console.log("[relayBiconomyMetaTransaction.wait] txReceipt", txReceipt);
-            return {
-                to: txReceipt?.to || contractAddress,
-                from: txReceipt?.from || metaTx.params.userAddress,
-                transactionHash: txHash,
-                logs: txReceipt?.logs || [],
-                effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice)
-            };
-        },
-        hash: relayTxResponse.txHash
-    };
-}
-export async function getResubmitted(args) {
-    const { chainId, metaTx } = args;
-    const biconomy = new Biconomy(metaTx.config.relayerUrl, metaTx.config.apiKey, metaTx.config.apiId);
-    const retriedHashesResponse = await biconomy.getResubmitted({
-        networkId: chainId,
-        transactionHash: metaTx.originalHash
-    });
-    return retriedHashesResponse.data;
-}
+import { utils, defaultConfigs } from "@bosonprotocol/common";
+import { storeMetadataOnTheGraph } from "../offers/storage";
+import { BigNumber } from "@ethersproject/bignumber";
+import { encodeCreateSeller, encodeOptInToSellerUpdate, encodeUpdateSeller } from "../accounts/interface";
+import { bosonExchangeHandlerIface } from "../exchanges/interface";
+import { bosonOfferHandlerIface, encodeCreateOffer, encodeCreateOfferBatch, encodeReserveRange } from "../offers/interface";
+import { prepareDataSignatureParameters } from "../utils/signature";
+import { Biconomy } 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 { encodeCallExternalContract, encodePreMint, encodeSetApprovalForAll, encodeSetApprovalForAllToContract } from "../voucher/interface";
+import { keccak256 } from "@ethersproject/keccak256";
+import { id } from "@ethersproject/hash";
+import { defaultAbiCoder } from "@ethersproject/abi";
+import { getNonce, verifyEIP712 } from "../forwarder/handler";
+import { isTrustedForwarder } from "../voucher/handler";
+export async function signMetaTx(args) {
+    const metaTransactionType = [
+        { name: "nonce", type: "uint256" },
+        { name: "from", type: "address" },
+        { name: "contractAddress", type: "address" },
+        { name: "functionName", type: "string" },
+        { name: "functionSignature", type: "bytes" }
+    ];
+    const customSignatureType = {
+        MetaTransaction: metaTransactionType
+    };
+    const signerAddress = await args.web3Lib.getSignerAddress();
+    const message = {
+        nonce: args.nonce,
+        from: signerAddress,
+        contractAddress: args.metaTxHandlerAddress,
+        functionName: args.functionName,
+        functionSignature: args.functionSignature
+    };
+    const signature = await prepareDataSignatureParameters({
+        ...args,
+        verifyingContractAddress: args.metaTxHandlerAddress,
+        customSignatureType,
+        primaryType: "MetaTransaction",
+        message
+    });
+    return {
+        functionName: args.functionName,
+        functionSignature: args.functionSignature,
+        ...signature
+    };
+}
+export async function signVoucherMetaTx(args) {
+    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 nonce = await getNonce({
+        contractAddress: args.forwarderAddress,
+        user: signerAddress,
+        web3Lib: args.web3Lib,
+        forwarderAbi: args.forwarderAbi
+    });
+    const message = {
+        from: signerAddress,
+        to: args.bosonVoucherAddress,
+        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,
+        request: message,
+        ...signature
+    };
+}
+export async function signBiconomyVoucherMetaTx(args) {
+    const customSignatureType = {
+        EIP712Domain: [
+            { name: "name", type: "string" },
+            { name: "version", type: "string" },
+            // { name: "chainId", type: "uint256" },
+            // { name: "verifyingContract", type: "address" }
+            { name: "verifyingContract", type: "address" },
+            { name: "salt", type: "bytes32" }
+        ],
+        ERC20ForwardRequest: [
+            { name: "from", type: "address" },
+            { name: "to", type: "address" },
+            { name: "token", type: "address" },
+            { name: "txGas", type: "uint256" },
+            { name: "tokenGasPrice", type: "uint256" },
+            { name: "batchId", type: "uint256" },
+            { name: "batchNonce", type: "uint256" },
+            { name: "deadline", type: "uint256" },
+            { name: "data", type: "bytes" }
+        ]
+    };
+    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(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,
+        token: "0x0000000000000000000000000000000000000000",
+        txGas: args.txGas,
+        tokenGasPrice: "0",
+        batchId: args.batchId,
+        batchNonce: nonce,
+        deadline: Math.floor(Date.now() / 1000 + 3600),
+        data: args.functionSignature
+    };
+    const signatureParams = await prepareDataSignatureParameters({
+        ...args,
+        chainId,
+        verifyingContractAddress: biconomyForwarderDomainData.verifyingContract,
+        customSignatureType,
+        primaryType: "ERC20ForwardRequest",
+        message,
+        customDomainData: {
+            ...biconomyForwarderDomainData
+            // chainId
+            // salt: undefined
+        }
+    });
+    const signature = signatureParams.signature;
+    const getDomainSeparator = async () => {
+        const domainData = biconomyForwarderDomainData;
+        const domainSeparator = keccak256(defaultAbiCoder.encode(["bytes32", "bytes32", "bytes32", "address", "bytes32"], [
+            id("EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"),
+            id(domainData.name),
+            id(domainData.version),
+            domainData.verifyingContract,
+            domainData.salt
+        ]));
+        return domainSeparator;
+    };
+    const domainSeparator = await getDomainSeparator();
+    // verify signature
+    const signatureVerified = await verifyEIP712({
+        request: message,
+        contractAddress: biconomyForwarderDomainData.verifyingContract,
+        web3Lib: args.web3Lib,
+        domainSeparator,
+        forwarderAbi: args.forwarderAbi,
+        signature
+    });
+    if (!signatureVerified) {
+        throw `Signature is not verified`;
+    }
+    return {
+        to: message.to,
+        domainSeparator,
+        request: message,
+        ...signatureParams,
+        signature,
+        functionSignature: args.functionSignature
+    };
+}
+export async function relayBiconomyMetaTransaction(args) {
+    const { chainId, contractAddress, metaTx } = args;
+    const biconomy = new Biconomy(metaTx.config.relayerUrl, metaTx.config.apiKey, metaTx.config.apiId);
+    const relayTxResponse = await biconomy.relayTransaction({
+        to: contractAddress,
+        params: [
+            metaTx.params.request,
+            metaTx.params.domainSeparator,
+            metaTx.params.signature
+        ],
+        from: metaTx.params.userAddress,
+        signatureType: "EIP712_SIGN"
+    });
+    return {
+        wait: async () => {
+            const waitResponse = await biconomy.wait({
+                networkId: chainId,
+                transactionHash: relayTxResponse.txHash
+            });
+            const txHash = waitResponse.data.newHash;
+            const txReceipt = await args.web3LibAdapter.getTransactionReceipt(txHash);
+            return {
+                to: txReceipt?.to || contractAddress,
+                from: txReceipt?.from || metaTx.params.userAddress,
+                transactionHash: txHash,
+                logs: txReceipt?.logs || [],
+                effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice)
+            };
+        },
+        hash: relayTxResponse.txHash
+    };
+}
+export async function signMetaTxCreateSeller(args) {
+    await storeMetadataOnTheGraph({
+        metadataUriOrHash: args.createSellerArgs.metadataUri,
+        metadataStorage: args.metadataStorage,
+        theGraphStorage: args.theGraphStorage
+    });
+    return signMetaTx({
+        ...args,
+        functionName: "createSeller((uint256,address,address,address,address,bool,string),(uint256,uint8),(string,uint256))",
+        functionSignature: encodeCreateSeller(args.createSellerArgs)
+    });
+}
+export async function signMetaTxUpdateSeller(args) {
+    await storeMetadataOnTheGraph({
+        metadataUriOrHash: args.updateSellerArgs.metadataUri,
+        metadataStorage: args.metadataStorage,
+        theGraphStorage: args.theGraphStorage
+    });
+    return signMetaTx({
+        ...args,
+        functionName: "updateSeller((uint256,address,address,address,address,bool,string),(uint256,uint8))",
+        functionSignature: encodeUpdateSeller(args.updateSellerArgs)
+    });
+}
+export async function signMetaTxOptInToSellerUpdate(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "optInToSellerUpdate(uint256,uint8[])",
+        functionSignature: encodeOptInToSellerUpdate(args.optInToSellerUpdateArgs)
+    });
+}
+export async function signMetaTxCreateOffer(args) {
+    utils.validation.createOfferArgsSchema.validateSync(args.createOfferArgs, {
+        abortEarly: false
+    });
+    await storeMetadataOnTheGraph({
+        metadataUriOrHash: args.createOfferArgs.metadataUri,
+        metadataStorage: args.metadataStorage,
+        theGraphStorage: args.theGraphStorage
+    });
+    return signMetaTx({
+        ...args,
+        functionName: "createOffer((uint256,uint256,uint256,uint256,uint256,uint256,address,string,string,bool),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),uint256,uint256)",
+        functionSignature: encodeCreateOffer(args.createOfferArgs)
+    });
+}
+export async function signMetaTxCreateOfferBatch(args) {
+    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: "createOfferBatch((uint256,uint256,uint256,uint256,uint256,uint256,address,string,string,bool)[],(uint256,uint256,uint256,uint256)[],(uint256,uint256,uint256)[],uint256[],uint256[])",
+        functionSignature: encodeCreateOfferBatch(args.createOffersArgs)
+    });
+}
+export async function signMetaTxVoidOffer(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "voidOffer(uint256)",
+        functionSignature: bosonOfferHandlerIface.encodeFunctionData("voidOffer", [
+            args.offerId
+        ])
+    });
+}
+export async function signMetaTxVoidOfferBatch(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "voidOfferBatch(uint256[])",
+        functionSignature: bosonOfferHandlerIface.encodeFunctionData("voidOfferBatch", [args.offerIds])
+    });
+}
+export async function signMetaTxExtendOffer(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "extendOffer(uint256,uint256)",
+        functionSignature: bosonOfferHandlerIface.encodeFunctionData("extendOffer", [args.offerId, args.validUntil])
+    });
+}
+export async function signMetaTxExtendOfferBatch(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "extendOfferBatch(uint256[],uint256)",
+        functionSignature: bosonOfferHandlerIface.encodeFunctionData("extendOfferBatch", [args.offerIds, args.validUntil])
+    });
+}
+export async function signMetaTxCompleteExchangeBatch(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "completeExchangeBatch(uint256[])",
+        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("completeExchangeBatch", [args.exchangeIds])
+    });
+}
+export async function signMetaTxExpireVoucher(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "expireVoucher(uint256)",
+        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("expireVoucher", [args.exchangeId])
+    });
+}
+export async function signMetaTxRevokeVoucher(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "revokeVoucher(uint256)",
+        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("revokeVoucher", [args.exchangeId])
+    });
+}
+export async function signMetaTxCreateGroup(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "createGroup((uint256,uint256,uint256[]),(uint8,uint8,address,uint256,uint256,uint256))",
+        functionSignature: encodeCreateGroup(args.createGroupArgs)
+    });
+}
+export async function signMetaTxReserveRange(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "reserveRange(uint256,uint256,address)",
+        functionSignature: encodeReserveRange(args.offerId, args.length, args.to)
+    });
+}
+export async function signMetaTxPreMint(args) {
+    const localConfig = defaultConfigs.find((config) => config.envName === "local");
+    const isLocal = localConfig.chainId === args.chainId;
+    const functionSignature = encodePreMint(args.offerId, args.amount);
+    if (isLocal) {
+        return signVoucherMetaTx({
+            ...args,
+            forwarderAddress: args.forwarderAddress,
+            functionSignature,
+            forwarderAbi: args.forwarderAbi
+        });
+    }
+    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,
+        batchId: args.batchId || "0",
+        txGas
+    });
+}
+export async function signMetaTxSetApprovalForAll(args) {
+    const localConfig = defaultConfigs.find((config) => config.envName === "local");
+    const isLocal = localConfig.chainId === args.chainId;
+    const functionSignature = encodeSetApprovalForAll(args.operator, args.approved);
+    if (isLocal) {
+        return signVoucherMetaTx({
+            ...args,
+            forwarderAddress: args.forwarderAddress,
+            functionSignature,
+            forwarderAbi: args.forwarderAbi
+        });
+    }
+    const txGas = 100000; // ~70000 estimation on 2023/02/03
+    return signBiconomyVoucherMetaTx({
+        ...args,
+        functionSignature,
+        forwarderAbi: args.forwarderAbi,
+        batchId: args.batchId || "0",
+        txGas
+    });
+}
+export async function signMetaTxSetApprovalForAllToContract(args, overrides = {}) {
+    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
+        });
+    }
+    const txGas = overrides.txGas || 100000; // TODO: estimate the gas needed
+    return signBiconomyVoucherMetaTx({
+        ...args,
+        functionSignature,
+        forwarderAbi: args.forwarderAbi,
+        batchId: args.batchId || "0",
+        txGas
+    });
+}
+export async function signMetaTxCallExternalContract(args, overrides = {}) {
+    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
+        });
+    }
+    const txGas = overrides.txGas || 500000; // TODO: estimate the gas needed
+    return signBiconomyVoucherMetaTx({
+        ...args,
+        functionSignature,
+        forwarderAbi: args.forwarderAbi,
+        batchId: args.batchId || "0",
+        txGas
+    });
+}
+export async function signMetaTxCreateOfferWithCondition(args) {
+    utils.validation.createOfferArgsSchema.validateSync(args.offerToCreate, {
+        abortEarly: false
+    });
+    await storeMetadataOnTheGraph({
+        metadataUriOrHash: args.offerToCreate.metadataUri,
+        metadataStorage: args.metadataStorage,
+        theGraphStorage: args.theGraphStorage
+    });
+    return signMetaTx({
+        ...args,
+        functionName: "createOfferWithCondition((uint256,uint256,uint256,uint256,uint256,uint256,address,string,string,bool),(uint256,uint256,uint256,uint256),(uint256,uint256,uint256),uint256,(uint8,uint8,address,uint256,uint256,uint256),uint256)",
+        functionSignature: encodeCreateOfferWithCondition(args.offerToCreate, args.condition)
+    });
+}
+export async function signMetaTxCommitToOffer(args) {
+    const functionName = "commitToOffer(address,uint256)";
+    const offerType = [
+        { name: "buyer", type: "address" },
+        { name: "offerId", type: "uint256" }
+    ];
+    const metaTransactionType = [
+        { name: "nonce", type: "uint256" },
+        { name: "from", type: "address" },
+        { name: "contractAddress", type: "address" },
+        { name: "functionName", type: "string" },
+        { name: "offerDetails", type: "MetaTxOfferDetails" }
+    ];
+    const customSignatureType = {
+        MetaTxCommitToOffer: metaTransactionType,
+        MetaTxOfferDetails: offerType
+    };
+    const buyerAddress = await args.web3Lib.getSignerAddress();
+    const message = {
+        nonce: args.nonce.toString(),
+        from: buyerAddress,
+        contractAddress: args.metaTxHandlerAddress,
+        functionName,
+        offerDetails: {
+            buyer: buyerAddress,
+            offerId: args.offerId.toString()
+        }
+    };
+    const signatureParams = await prepareDataSignatureParameters({
+        ...args,
+        verifyingContractAddress: args.metaTxHandlerAddress,
+        customSignatureType,
+        primaryType: "MetaTxCommitToOffer",
+        message
+    });
+    return {
+        ...signatureParams,
+        functionName,
+        functionSignature: bosonExchangeHandlerIface.encodeFunctionData("commitToOffer", [buyerAddress, args.offerId])
+    };
+}
+export async function signMetaTxCancelVoucher(args) {
+    return makeExchangeMetaTxSigner("cancelVoucher(uint256)")(args);
+}
+export async function signMetaTxRedeemVoucher(args) {
+    return makeExchangeMetaTxSigner("redeemVoucher(uint256)")(args);
+}
+export async function signMetaTxCompleteExchange(args) {
+    return makeExchangeMetaTxSigner("completeExchange(uint256)")(args);
+}
+export async function signMetaTxRetractDispute(args) {
+    return makeExchangeMetaTxSigner("retractDispute(uint256)", bosonDisputeHandlerIface)(args);
+}
+export async function signMetaTxEscalateDispute(args) {
+    return makeExchangeMetaTxSigner("escalateDispute(uint256)", bosonDisputeHandlerIface)(args);
+}
+export async function signMetaTxRaiseDispute(args) {
+    return makeExchangeMetaTxSigner("raiseDispute(uint256)", bosonDisputeHandlerIface)(args);
+}
+export async function signMetaTxResolveDispute(args) {
+    const functionName = "resolveDispute(uint256,uint256,bytes32,bytes32,uint8)";
+    const disputeResolutionType = [
+        { name: "exchangeId", type: "uint256" },
+        { name: "buyerPercentBasisPoints", type: "uint256" },
+        { name: "sigR", type: "bytes32" },
+        { name: "sigS", type: "bytes32" },
+        { name: "sigV", type: "uint8" }
+    ];
+    const metaTransactionType = [
+        { name: "nonce", type: "uint256" },
+        { name: "from", type: "address" },
+        { name: "contractAddress", type: "address" },
+        { name: "functionName", type: "string" },
+        { name: "disputeResolutionDetails", type: "MetaTxDisputeResolutionDetails" }
+    ];
+    const customSignatureType = {
+        MetaTxDisputeResolution: metaTransactionType,
+        MetaTxDisputeResolutionDetails: disputeResolutionType
+    };
+    const message = {
+        nonce: args.nonce.toString(),
+        from: await args.web3Lib.getSignerAddress(),
+        contractAddress: args.metaTxHandlerAddress,
+        functionName,
+        disputeResolutionDetails: {
+            exchangeId: args.exchangeId.toString(),
+            buyerPercentBasisPoints: args.buyerPercent.toString(),
+            sigR: args.counterpartySig.r,
+            sigS: args.counterpartySig.s,
+            sigV: args.counterpartySig.v
+        }
+    };
+    const signatureParams = await prepareDataSignatureParameters({
+        ...args,
+        verifyingContractAddress: args.metaTxHandlerAddress,
+        customSignatureType,
+        primaryType: "MetaTxDisputeResolution",
+        message
+    });
+    return {
+        ...signatureParams,
+        functionName,
+        functionSignature: bosonDisputeHandlerIface.encodeFunctionData(
+        // remove params in brackets from string
+        functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [
+            args.exchangeId,
+            args.buyerPercent,
+            args.counterpartySig.r,
+            args.counterpartySig.s,
+            args.counterpartySig.v
+        ])
+    };
+}
+export async function signMetaTxExtendDisputeTimeout(args) {
+    return signMetaTx({
+        ...args,
+        functionName: "extendDisputeTimeout(uint256,uint256)",
+        functionSignature: bosonDisputeHandlerIface.encodeFunctionData("extendDisputeTimeout", [args.exchangeId, args.newTimeout])
+    });
+}
+export async function signMetaTxWithdrawFunds(args) {
+    const functionName = "withdrawFunds(uint256,address[],uint256[])";
+    const fundType = [
+        { name: "entityId", type: "uint256" },
+        { name: "tokenList", type: "address[]" },
+        { name: "tokenAmounts", type: "uint256[]" }
+    ];
+    const metaTransactionType = [
+        { name: "nonce", type: "uint256" },
+        { name: "from", type: "address" },
+        { name: "contractAddress", type: "address" },
+        { name: "functionName", type: "string" },
+        { name: "fundDetails", type: "MetaTxFundDetails" }
+    ];
+    const customSignatureType = {
+        MetaTxFund: metaTransactionType,
+        MetaTxFundDetails: fundType
+    };
+    const message = {
+        nonce: args.nonce.toString(),
+        from: await args.web3Lib.getSignerAddress(),
+        contractAddress: args.metaTxHandlerAddress,
+        functionName,
+        fundDetails: {
+            entityId: args.entityId.toString(),
+            tokenList: args.tokenList,
+            tokenAmounts: args.tokenAmounts.map((bn) => bn.toString())
+        }
+    };
+    const signatureParams = await prepareDataSignatureParameters({
+        ...args,
+        verifyingContractAddress: args.metaTxHandlerAddress,
+        customSignatureType,
+        primaryType: "MetaTxFund",
+        message
+    });
+    return {
+        ...signatureParams,
+        functionName,
+        functionSignature: encodeWithdrawFunds(args.entityId, args.tokenList, args.tokenAmounts)
+    };
+}
+export async function signMetaTxDepositFunds(args) {
+    if (!isAddress(args.fundsTokenAddress)) {
+        throw new Error(`Invalid fundsTokenAddress: ${args.fundsTokenAddress}`);
+    }
+    if (args.fundsTokenAddress === AddressZero) {
+        throw new Error(`Meta transaction can't be used to deposit native currency`);
+    }
+    return signMetaTx({
+        ...args,
+        functionName: "depositFunds(uint256,address,uint256)",
+        functionSignature: encodeDepositFunds(args.sellerId, args.fundsTokenAddress, args.fundsAmount)
+    });
+}
+function makeExchangeMetaTxSigner(functionName, handlerIface = bosonExchangeHandlerIface) {
+    return async function signExchangeMetaTx(args) {
+        const exchangeType = [{ name: "exchangeId", type: "uint256" }];
+        const metaTransactionType = [
+            { name: "nonce", type: "uint256" },
+            { name: "from", type: "address" },
+            { name: "contractAddress", type: "address" },
+            { name: "functionName", type: "string" },
+            { name: "exchangeDetails", type: "MetaTxExchangeDetails" }
+        ];
+        const customSignatureType = {
+            MetaTxExchange: metaTransactionType,
+            MetaTxExchangeDetails: exchangeType
+        };
+        const buyerAddress = await args.web3Lib.getSignerAddress();
+        const message = {
+            nonce: args.nonce.toString(),
+            from: buyerAddress,
+            contractAddress: args.metaTxHandlerAddress,
+            functionName,
+            exchangeDetails: {
+                exchangeId: args.exchangeId.toString()
+            }
+        };
+        const signatureParams = await prepareDataSignatureParameters({
+            ...args,
+            verifyingContractAddress: args.metaTxHandlerAddress,
+            customSignatureType,
+            primaryType: "MetaTxExchange",
+            message
+        });
+        return {
+            ...signatureParams,
+            functionName,
+            functionSignature: handlerIface.encodeFunctionData(
+            // remove params in brackets from string
+            functionName.replace(/\(([^)]*)\)[^(]*$/, ""), [args.exchangeId])
+        };
+    };
+}
+export async function relayMetaTransaction(args) {
+    const { chainId, contractAddress, metaTx } = args;
+    const biconomy = new Biconomy(metaTx.config.relayerUrl, metaTx.config.apiKey, metaTx.config.apiId);
+    const relayTxResponse = await biconomy.relayTransaction({
+        to: contractAddress,
+        params: [
+            metaTx.params.userAddress,
+            metaTx.params.functionName,
+            metaTx.params.functionSignature,
+            metaTx.params.nonce,
+            metaTx.params.sigR,
+            metaTx.params.sigS,
+            metaTx.params.sigV
+        ],
+        from: metaTx.params.userAddress
+    });
+    return {
+        wait: async () => {
+            const waitResponse = await biconomy.wait({
+                networkId: chainId,
+                transactionHash: relayTxResponse.txHash
+            });
+            const txHash = waitResponse.data.newHash;
+            const txReceipt = await args.web3LibAdapter.getTransactionReceipt(txHash);
+            console.log("[relayBiconomyMetaTransaction.wait] txReceipt", txReceipt);
+            return {
+                to: txReceipt?.to || contractAddress,
+                from: txReceipt?.from || metaTx.params.userAddress,
+                transactionHash: txHash,
+                logs: txReceipt?.logs || [],
+                effectiveGasPrice: BigNumber.from(waitResponse.data.newGasPrice)
+            };
+        },
+        hash: relayTxResponse.txHash
+    };
+}
+export async function getResubmitted(args) {
+    const { chainId, metaTx } = args;
+    const biconomy = new Biconomy(metaTx.config.relayerUrl, metaTx.config.apiKey, metaTx.config.apiId);
+    const retriedHashesResponse = await biconomy.getResubmitted({
+        networkId: chainId,
+        transactionHash: metaTx.originalHash
+    });
+    return retriedHashesResponse.data;
+}
 //# sourceMappingURL=handler.js.map