const callWithSyncFeeERC2771 = async (
  request: CallWithSyncFeeERC2771Request | CallWithSyncFeeConcurrentERC2771Request,
  signerOrProvider: ethers.BrowserProvider | ethers.Signer,
  options?: RelayRequestOptions,
  apiKey?: string
): Promise<RelayResponse>

type RelayResponse = {
  taskId: string;
};

getSignatureDataERC2771 = (
  request: CallWithERC2771Request | CallWithConcurrentERC2771Request,
  signerOrProvider: ethers.BrowserProvider | ethers.Signer,
  type: ERC2771Type
): Promise<SignatureData>

type SignatureData = ConcurrentSignatureData | SequentialSignatureData;

type ConcurrentSignatureData = {
  struct: CallWithConcurrentERC2771Struct;
  signature: string;
};

type SequentialSignatureData = {
  struct: CallWithERC2771Struct;
  signature: string;
};

getDataToSignERC2771 = (
  request: CallWithERC2771Request | CallWithConcurrentERC2771Request,
  type: ERC2771Type,
  signerOrProvider?: ethers.BrowserProvider | ethers.Signer,
): Promise<PayloadToSign>

type PayloadToSign = ConcurrentPayloadToSign | SequentialPayloadToSign;

type ConcurrentPayloadToSign = {
  struct: CallWithConcurrentERC2771Struct;
  typedData: CallWithSyncFeeConcurrentERC2771PayloadToSign;
};

type SequentialPayloadToSign = {
  struct: CallWithERC2771Struct;
  typedData: CallWithSyncFeeERC2771PayloadToSign;
};

const callWithSyncFeeERC2771WithSignature = async (
    struct: CallWithERC2771Struct | CallWithConcurrentERC2771Struct;
    syncFeeParams: BaseCallWithSyncFeeParams;
    signature: string;
    options?: RelayRequestOptions;
    apiKey?: string
): Promise<RelayResponse>

type RelayResponse = {
  taskId: string;
};

type RelayRequestOptions = {
  gasLimit?: BigNumberish;
  retries?: number;
};

type SequentialERC2771Request = {
  chainId: BigNumberish;
  target: string;
  data: BytesLike;
  user: string;
  userDeadline?: BigNumberish;
  feeToken: string;
  isRelayContext?: boolean;
  isConcurrent?: false;
  userNonce?: BigNumberish;
};

type ConcurrentERC2771Request = {
  chainId: BigNumberish;
  target: string;
  data: BytesLike;
  user: string;
  userDeadline?: BigNumberish;
  feeToken: string;
  isRelayContext?: boolean;
  isConcurrent: true;
  userSalt?: string;
};

// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;

import {
    GelatoRelayContextERC2771
} from "@gelatonetwork/relay-context/contracts/GelatoRelayContextERC2771.sol";

import {Address} from "@openzeppelin/contracts/utils/Address.sol";

// Inheriting GelatoRelayContext gives access to:
// 1. _getFeeCollector(): returns the address of Gelato's feeCollector
// 2. _getFeeToken(): returns the address of the fee token
// 3. _getFee(): returns the fee to pay
// 4. _transferRelayFee(): transfers the required fee to Gelato's feeCollector.abi
// 5. _transferRelayFeeCapped(uint256 maxFee): transfers the fee to Gelato
//    only if fee < maxFee
// 6. function _getMsgSender(): decodes and returns the user's address from the
//    calldata, which can be used to refer to user safely instead of msg.sender
//    (which is Gelato Relay in this case).
// 7. _getMsgData(): returns the original msg.data without appended information
// 8. onlyGelatoRelay modifier: allows only Gelato Relay's smart contract
//    to call the function
contract CounterRelayContextERC2771 is GelatoRelayContextERC2771 {
    using Address for address payable;

    mapping(address => uint256) public contextCounter;

    // emitting an event for testing purposes
    event IncrementCounter(address msgSender);

    // `increment` is the target function to call.
    // This function increments a counter variable which is 
    // mapped to every _getMsgSender(), the address of the user.
    // This way each user off-chain has their own counter 
    // variable on-chain.
    function increment() external onlyGelatoRelayERC2771 {
        // Payment to Gelato
        // NOTE: be very careful here!
        // if you do not use the onlyGelatoRelay modifier,
        // anyone could encode themselves as the fee collector
        // in the low-level data and drain tokens from this contract.
        _transferRelayFee();

        // Incrementing the counter mapped to the _getMsgSender()
        contextCounter[_getMsgSender()]++;
        
        emit IncrementCounter(_getMsgSender());
    }
    
    // `incrementFeeCapped` is the target function to call.
    // This function uses `_transferRelayFeeCapped` method to ensure 
    // better control of gas fees. If gas fees are above the maxFee value 
    // the transaction will not be executed.
    // The maxFee will be passed as an argument to the contract call.
    // This function increments a counter variable by 1
    // IMPORTANT: with `callWithSyncFee` you need to implement 
    // your own smart contract security measures, as this 
    // function can be called by any third party and not only by 
    // Gelato Relay. If not done properly, funds kept in this
    // smart contract can be stolen.
    function incrementFeeCapped(uint256 maxFee) external onlyGelatoRelayERC2771 {
        // Payment to Gelato
        // NOTE: be very careful here!
        // if you do not use the onlyGelatoRelay modifier,
        // anyone could encode themselves as the fee collector
        // in the low-level data and drain tokens from this contract.
        _transferRelayFeeCapped(maxFee);

        // Incrementing the counter mapped to the _getMsgSender()
        contextCounter[_getMsgSender()]++;

        emit IncrementCounter(_getMsgSender());
    }
}

import { GelatoRelay, CallWithSyncFeeERC2771Request } from "@gelatonetwork/relay-sdk";

contract: {
    relay1BalanceERC2771: "trustedForwarder for method sponsoredCallERC2771",
    relayERC2771: "trustedForwarder for method callWithSyncFeeERC2771",
    relay1BalanceConcurrentERC2771: "trustedForwarder for method concurrent sponsoredCallERC2771",
    relayConcurrentERC2771: "trustedForwarder for method concurrent callWithSyncFeeERC2771",
    relay1BalanceConcurrentERC2771zkSync: "trustedForwarder for method concurrent sponsoredCallERC2771 on zkSync",
    relay1BalanceERC2771zkSync: "trustedForwarder for method sponsoredCallERC2771 on zkSync",
    relayConcurrentERC2771zkSync: "trustedForwarder for method concurrent callWithSyncFeeERC2771 on zkSync",
    relayERC2771zkSync: "trustedForwarder for method callWithSyncFeeERC2771 on zkSync",
}

const relay = new GelatoRelay({
    contract: {
        relayERC2771: "0xb539068872230f20456CF38EC52EF2f91AF4AE49"
    }
});

// target contract address
const counter = "<your counter contract address>";

// using a human-readable ABI for generating the payload
const abi = ["function increment()"];

// address of the token used to pay fees
const feeToken = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";

// connect to the blockchain via a front-end provider
const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();
const user = await signer.getAddress();

// instantiate the target contract object
const contract = new ethers.Contract(counter, abi, signer);

// example calling the increment() method
const { data } = await contract.increment.populateTransaction();

// populate the relay SDK request body
const request: CallWithSyncFeeERC2771Request = {
    chainId: (await provider.getNetwork()).chainId,
    target: counter,
    data: data,
    user: user,
    feeToken: feeToken,
    isRelayContext: true,
};

// send relayRequest to Gelato Relay API
const relayResponse = await relay.callWithSyncFeeERC2771(request, provider);

// -----------------------------------------------------------------
// the following is an alternative example using Gelato Fee Oracle, 
// setting maxFee, and calling the incrementFeeCapped(maxFee) method

// retrieve the estimate fee from Gelato Fee Oracle
const fee = await relay.getEstimatedFee(
    (await provider.getNetwork()).chainId,
    feeToken,
    gasLimit,
    false,
);

// you can use 2x or 3x to set your maxFee
const maxFee = fee * 2;

// example calling the incrementFeeCapped(maxFee) method
const { dataMaxFee } = await contract.incrementFeeCapped.populateTransaction(maxFee);

// populate the relay SDK request body
const requestMaxFee: CallWithSyncFeeERC2771Request = {
    chainId: (await provider.getNetwork()).chainId,
    target: counter,
    data: dataMaxFee,
    user: user,
    feeToken: feeToken,
    isRelayContext: true,
};

// send relayRequest to Gelato Relay API
const relayResponseMaxFee = await relay.callWithSyncFeeERC2771(requestMaxFee, provider);