using System.Numerics;
using Managing.ABI.GmxV2.ExchangeRouter.ContractDefinition;
using Nethereum.RPC.Eth.DTOs;
using Nethereum.Web3;

namespace Managing.ABI.GmxV2.ExchangeRouter
{
    public partial class ExchangeRouterService : ContractWeb3ServiceBase
    {
        public static Task<TransactionReceipt> DeployContractAndWaitForReceiptAsync(IWeb3 web3,
            ExchangeRouterDeployment exchangeRouterDeployment, CancellationTokenSource cancellationTokenSource = null)
        {
            return web3.Eth.GetContractDeploymentHandler<ExchangeRouterDeployment>()
                .SendRequestAndWaitForReceiptAsync(exchangeRouterDeployment, cancellationTokenSource);
        }

        public static Task<string> DeployContractAsync(IWeb3 web3, ExchangeRouterDeployment exchangeRouterDeployment)
        {
            return web3.Eth.GetContractDeploymentHandler<ExchangeRouterDeployment>()
                .SendRequestAsync(exchangeRouterDeployment);
        }

        public static async Task<ExchangeRouterService> DeployContractAndGetServiceAsync(IWeb3 web3,
            ExchangeRouterDeployment exchangeRouterDeployment, CancellationTokenSource cancellationTokenSource = null)
        {
            var receipt =
                await DeployContractAndWaitForReceiptAsync(web3, exchangeRouterDeployment, cancellationTokenSource);
            return new ExchangeRouterService(web3, receipt.ContractAddress);
        }

        public ExchangeRouterService(IWeb3 web3, string contractAddress) : base(web3, contractAddress)
        {
        }

        public Task<string> CancelDepositRequestAsync(CancelDepositFunction cancelDepositFunction)
        {
            return ContractHandler.SendRequestAsync(cancelDepositFunction);
        }

        public Task<TransactionReceipt> CancelDepositRequestAndWaitForReceiptAsync(
            CancelDepositFunction cancelDepositFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelDepositFunction, cancellationToken);
        }

        public Task<string> CancelDepositRequestAsync(byte[] key)
        {
            var cancelDepositFunction = new CancelDepositFunction();
            cancelDepositFunction.Key = key;

            return ContractHandler.SendRequestAsync(cancelDepositFunction);
        }

        public Task<TransactionReceipt> CancelDepositRequestAndWaitForReceiptAsync(byte[] key,
            CancellationTokenSource cancellationToken = null)
        {
            var cancelDepositFunction = new CancelDepositFunction();
            cancelDepositFunction.Key = key;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelDepositFunction, cancellationToken);
        }

        public Task<string> CancelOrderRequestAsync(CancelOrderFunction cancelOrderFunction)
        {
            return ContractHandler.SendRequestAsync(cancelOrderFunction);
        }

        public Task<TransactionReceipt> CancelOrderRequestAndWaitForReceiptAsync(
            CancelOrderFunction cancelOrderFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelOrderFunction, cancellationToken);
        }

        public Task<string> CancelOrderRequestAsync(byte[] key)
        {
            var cancelOrderFunction = new CancelOrderFunction();
            cancelOrderFunction.Key = key;

            return ContractHandler.SendRequestAsync(cancelOrderFunction);
        }

        public Task<TransactionReceipt> CancelOrderRequestAndWaitForReceiptAsync(byte[] key,
            CancellationTokenSource cancellationToken = null)
        {
            var cancelOrderFunction = new CancelOrderFunction();
            cancelOrderFunction.Key = key;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelOrderFunction, cancellationToken);
        }

        public Task<string> CancelShiftRequestAsync(CancelShiftFunction cancelShiftFunction)
        {
            return ContractHandler.SendRequestAsync(cancelShiftFunction);
        }

        public Task<TransactionReceipt> CancelShiftRequestAndWaitForReceiptAsync(
            CancelShiftFunction cancelShiftFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelShiftFunction, cancellationToken);
        }

        public Task<string> CancelShiftRequestAsync(byte[] key)
        {
            var cancelShiftFunction = new CancelShiftFunction();
            cancelShiftFunction.Key = key;

            return ContractHandler.SendRequestAsync(cancelShiftFunction);
        }

        public Task<TransactionReceipt> CancelShiftRequestAndWaitForReceiptAsync(byte[] key,
            CancellationTokenSource cancellationToken = null)
        {
            var cancelShiftFunction = new CancelShiftFunction();
            cancelShiftFunction.Key = key;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelShiftFunction, cancellationToken);
        }

        public Task<string> CancelWithdrawalRequestAsync(CancelWithdrawalFunction cancelWithdrawalFunction)
        {
            return ContractHandler.SendRequestAsync(cancelWithdrawalFunction);
        }

        public Task<TransactionReceipt> CancelWithdrawalRequestAndWaitForReceiptAsync(
            CancelWithdrawalFunction cancelWithdrawalFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelWithdrawalFunction, cancellationToken);
        }

        public Task<string> CancelWithdrawalRequestAsync(byte[] key)
        {
            var cancelWithdrawalFunction = new CancelWithdrawalFunction();
            cancelWithdrawalFunction.Key = key;

            return ContractHandler.SendRequestAsync(cancelWithdrawalFunction);
        }

        public Task<TransactionReceipt> CancelWithdrawalRequestAndWaitForReceiptAsync(byte[] key,
            CancellationTokenSource cancellationToken = null)
        {
            var cancelWithdrawalFunction = new CancelWithdrawalFunction();
            cancelWithdrawalFunction.Key = key;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(cancelWithdrawalFunction, cancellationToken);
        }

        public Task<string> ClaimAffiliateRewardsRequestAsync(
            ClaimAffiliateRewardsFunction claimAffiliateRewardsFunction)
        {
            return ContractHandler.SendRequestAsync(claimAffiliateRewardsFunction);
        }

        public Task<TransactionReceipt> ClaimAffiliateRewardsRequestAndWaitForReceiptAsync(
            ClaimAffiliateRewardsFunction claimAffiliateRewardsFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimAffiliateRewardsFunction, cancellationToken);
        }

        public Task<string> ClaimAffiliateRewardsRequestAsync(List<string> markets, List<string> tokens,
            string receiver)
        {
            var claimAffiliateRewardsFunction = new ClaimAffiliateRewardsFunction();
            claimAffiliateRewardsFunction.Markets = markets;
            claimAffiliateRewardsFunction.Tokens = tokens;
            claimAffiliateRewardsFunction.Receiver = receiver;

            return ContractHandler.SendRequestAsync(claimAffiliateRewardsFunction);
        }

        public Task<TransactionReceipt> ClaimAffiliateRewardsRequestAndWaitForReceiptAsync(List<string> markets,
            List<string> tokens, string receiver, CancellationTokenSource cancellationToken = null)
        {
            var claimAffiliateRewardsFunction = new ClaimAffiliateRewardsFunction();
            claimAffiliateRewardsFunction.Markets = markets;
            claimAffiliateRewardsFunction.Tokens = tokens;
            claimAffiliateRewardsFunction.Receiver = receiver;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimAffiliateRewardsFunction, cancellationToken);
        }

        public Task<string> ClaimCollateralRequestAsync(ClaimCollateralFunction claimCollateralFunction)
        {
            return ContractHandler.SendRequestAsync(claimCollateralFunction);
        }

        public Task<TransactionReceipt> ClaimCollateralRequestAndWaitForReceiptAsync(
            ClaimCollateralFunction claimCollateralFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimCollateralFunction, cancellationToken);
        }

        public Task<string> ClaimCollateralRequestAsync(List<string> markets, List<string> tokens,
            List<BigInteger> timeKeys, string receiver)
        {
            var claimCollateralFunction = new ClaimCollateralFunction();
            claimCollateralFunction.Markets = markets;
            claimCollateralFunction.Tokens = tokens;
            claimCollateralFunction.TimeKeys = timeKeys;
            claimCollateralFunction.Receiver = receiver;

            return ContractHandler.SendRequestAsync(claimCollateralFunction);
        }

        public Task<TransactionReceipt> ClaimCollateralRequestAndWaitForReceiptAsync(List<string> markets,
            List<string> tokens, List<BigInteger> timeKeys, string receiver,
            CancellationTokenSource cancellationToken = null)
        {
            var claimCollateralFunction = new ClaimCollateralFunction();
            claimCollateralFunction.Markets = markets;
            claimCollateralFunction.Tokens = tokens;
            claimCollateralFunction.TimeKeys = timeKeys;
            claimCollateralFunction.Receiver = receiver;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimCollateralFunction, cancellationToken);
        }

        public Task<string> ClaimFundingFeesRequestAsync(ClaimFundingFeesFunction claimFundingFeesFunction)
        {
            return ContractHandler.SendRequestAsync(claimFundingFeesFunction);
        }

        public Task<TransactionReceipt> ClaimFundingFeesRequestAndWaitForReceiptAsync(
            ClaimFundingFeesFunction claimFundingFeesFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimFundingFeesFunction, cancellationToken);
        }

        public Task<string> ClaimFundingFeesRequestAsync(List<string> markets, List<string> tokens, string receiver)
        {
            var claimFundingFeesFunction = new ClaimFundingFeesFunction();
            claimFundingFeesFunction.Markets = markets;
            claimFundingFeesFunction.Tokens = tokens;
            claimFundingFeesFunction.Receiver = receiver;

            return ContractHandler.SendRequestAsync(claimFundingFeesFunction);
        }

        public Task<TransactionReceipt> ClaimFundingFeesRequestAndWaitForReceiptAsync(List<string> markets,
            List<string> tokens, string receiver, CancellationTokenSource cancellationToken = null)
        {
            var claimFundingFeesFunction = new ClaimFundingFeesFunction();
            claimFundingFeesFunction.Markets = markets;
            claimFundingFeesFunction.Tokens = tokens;
            claimFundingFeesFunction.Receiver = receiver;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimFundingFeesFunction, cancellationToken);
        }

        public Task<string> ClaimUiFeesRequestAsync(ClaimUiFeesFunction claimUiFeesFunction)
        {
            return ContractHandler.SendRequestAsync(claimUiFeesFunction);
        }

        public Task<TransactionReceipt> ClaimUiFeesRequestAndWaitForReceiptAsync(
            ClaimUiFeesFunction claimUiFeesFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimUiFeesFunction, cancellationToken);
        }

        public Task<string> ClaimUiFeesRequestAsync(List<string> markets, List<string> tokens, string receiver)
        {
            var claimUiFeesFunction = new ClaimUiFeesFunction();
            claimUiFeesFunction.Markets = markets;
            claimUiFeesFunction.Tokens = tokens;
            claimUiFeesFunction.Receiver = receiver;

            return ContractHandler.SendRequestAsync(claimUiFeesFunction);
        }

        public Task<TransactionReceipt> ClaimUiFeesRequestAndWaitForReceiptAsync(List<string> markets,
            List<string> tokens, string receiver, CancellationTokenSource cancellationToken = null)
        {
            var claimUiFeesFunction = new ClaimUiFeesFunction();
            claimUiFeesFunction.Markets = markets;
            claimUiFeesFunction.Tokens = tokens;
            claimUiFeesFunction.Receiver = receiver;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(claimUiFeesFunction, cancellationToken);
        }

        public Task<string> CreateDepositRequestAsync(CreateDepositFunction createDepositFunction)
        {
            return ContractHandler.SendRequestAsync(createDepositFunction);
        }

        public Task<TransactionReceipt> CreateDepositRequestAndWaitForReceiptAsync(
            CreateDepositFunction createDepositFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(createDepositFunction, cancellationToken);
        }

        public Task<string> CreateDepositRequestAsync(CreateDepositParams @params)
        {
            var createDepositFunction = new CreateDepositFunction();
            createDepositFunction.Params = @params;

            return ContractHandler.SendRequestAsync(createDepositFunction);
        }

        public Task<TransactionReceipt> CreateDepositRequestAndWaitForReceiptAsync(CreateDepositParams @params,
            CancellationTokenSource cancellationToken = null)
        {
            var createDepositFunction = new CreateDepositFunction();
            createDepositFunction.Params = @params;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(createDepositFunction, cancellationToken);
        }

        public Task<string> CreateOrderRequestAsync(CreateOrderFunction createOrderFunction)
        {
            return ContractHandler.SendRequestAsync(createOrderFunction);
        }

        public Task<TransactionReceipt> CreateOrderRequestAndWaitForReceiptAsync(
            CreateOrderFunction createOrderFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(createOrderFunction, cancellationToken);
        }

        public Task<string> CreateOrderRequestAsync(CreateOrderParams @params)
        {
            var createOrderFunction = new CreateOrderFunction();
            createOrderFunction.Params = @params;

            return ContractHandler.SendRequestAsync(createOrderFunction);
        }

        public Task<TransactionReceipt> CreateOrderRequestAndWaitForReceiptAsync(CreateOrderParams @params,
            CancellationTokenSource cancellationToken = null)
        {
            var createOrderFunction = new CreateOrderFunction();
            createOrderFunction.Params = @params;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(createOrderFunction, cancellationToken);
        }

        public Task<string> CreateShiftRequestAsync(CreateShiftFunction createShiftFunction)
        {
            return ContractHandler.SendRequestAsync(createShiftFunction);
        }

        public Task<TransactionReceipt> CreateShiftRequestAndWaitForReceiptAsync(
            CreateShiftFunction createShiftFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(createShiftFunction, cancellationToken);
        }

        public Task<string> CreateShiftRequestAsync(CreateShiftParams @params)
        {
            var createShiftFunction = new CreateShiftFunction();
            createShiftFunction.Params = @params;

            return ContractHandler.SendRequestAsync(createShiftFunction);
        }

        public Task<TransactionReceipt> CreateShiftRequestAndWaitForReceiptAsync(CreateShiftParams @params,
            CancellationTokenSource cancellationToken = null)
        {
            var createShiftFunction = new CreateShiftFunction();
            createShiftFunction.Params = @params;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(createShiftFunction, cancellationToken);
        }

        public Task<string> CreateWithdrawalRequestAsync(CreateWithdrawalFunction createWithdrawalFunction)
        {
            return ContractHandler.SendRequestAsync(createWithdrawalFunction);
        }

        public Task<TransactionReceipt> CreateWithdrawalRequestAndWaitForReceiptAsync(
            CreateWithdrawalFunction createWithdrawalFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(createWithdrawalFunction, cancellationToken);
        }

        public Task<string> CreateWithdrawalRequestAsync(CreateWithdrawalParams @params)
        {
            var createWithdrawalFunction = new CreateWithdrawalFunction();
            createWithdrawalFunction.Params = @params;

            return ContractHandler.SendRequestAsync(createWithdrawalFunction);
        }

        public Task<TransactionReceipt> CreateWithdrawalRequestAndWaitForReceiptAsync(CreateWithdrawalParams @params,
            CancellationTokenSource cancellationToken = null)
        {
            var createWithdrawalFunction = new CreateWithdrawalFunction();
            createWithdrawalFunction.Params = @params;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(createWithdrawalFunction, cancellationToken);
        }

        public Task<string> DataStoreQueryAsync(DataStoreFunction dataStoreFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<DataStoreFunction, string>(dataStoreFunction, blockParameter);
        }


        public Task<string> DataStoreQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<DataStoreFunction, string>(null, blockParameter);
        }

        public Task<string> DepositHandlerQueryAsync(DepositHandlerFunction depositHandlerFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<DepositHandlerFunction, string>(depositHandlerFunction, blockParameter);
        }


        public Task<string> DepositHandlerQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<DepositHandlerFunction, string>(null, blockParameter);
        }

        public Task<string> EventEmitterQueryAsync(EventEmitterFunction eventEmitterFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<EventEmitterFunction, string>(eventEmitterFunction, blockParameter);
        }


        public Task<string> EventEmitterQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<EventEmitterFunction, string>(null, blockParameter);
        }

        public Task<string> ExecuteAtomicWithdrawalRequestAsync(
            ExecuteAtomicWithdrawalFunction executeAtomicWithdrawalFunction)
        {
            return ContractHandler.SendRequestAsync(executeAtomicWithdrawalFunction);
        }

        public Task<TransactionReceipt> ExecuteAtomicWithdrawalRequestAndWaitForReceiptAsync(
            ExecuteAtomicWithdrawalFunction executeAtomicWithdrawalFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(executeAtomicWithdrawalFunction,
                cancellationToken);
        }

        public Task<string> ExecuteAtomicWithdrawalRequestAsync(CreateWithdrawalParams @params,
            SetPricesParams oracleParams)
        {
            var executeAtomicWithdrawalFunction = new ExecuteAtomicWithdrawalFunction();
            executeAtomicWithdrawalFunction.Params = @params;
            executeAtomicWithdrawalFunction.OracleParams = oracleParams;

            return ContractHandler.SendRequestAsync(executeAtomicWithdrawalFunction);
        }

        public Task<TransactionReceipt> ExecuteAtomicWithdrawalRequestAndWaitForReceiptAsync(
            CreateWithdrawalParams @params, SetPricesParams oracleParams,
            CancellationTokenSource cancellationToken = null)
        {
            var executeAtomicWithdrawalFunction = new ExecuteAtomicWithdrawalFunction();
            executeAtomicWithdrawalFunction.Params = @params;
            executeAtomicWithdrawalFunction.OracleParams = oracleParams;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(executeAtomicWithdrawalFunction,
                cancellationToken);
        }

        public Task<string> ExternalHandlerQueryAsync(ExternalHandlerFunction externalHandlerFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<ExternalHandlerFunction, string>(externalHandlerFunction, blockParameter);
        }


        public Task<string> ExternalHandlerQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<ExternalHandlerFunction, string>(null, blockParameter);
        }

        public Task<string> MakeExternalCallsRequestAsync(MakeExternalCallsFunction makeExternalCallsFunction)
        {
            return ContractHandler.SendRequestAsync(makeExternalCallsFunction);
        }

        public Task<TransactionReceipt> MakeExternalCallsRequestAndWaitForReceiptAsync(
            MakeExternalCallsFunction makeExternalCallsFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(makeExternalCallsFunction, cancellationToken);
        }

        public Task<string> MakeExternalCallsRequestAsync(List<string> externalCallTargets,
            List<byte[]> externalCallDataList, List<string> refundTokens, List<string> refundReceivers)
        {
            var makeExternalCallsFunction = new MakeExternalCallsFunction();
            makeExternalCallsFunction.ExternalCallTargets = externalCallTargets;
            makeExternalCallsFunction.ExternalCallDataList = externalCallDataList;
            makeExternalCallsFunction.RefundTokens = refundTokens;
            makeExternalCallsFunction.RefundReceivers = refundReceivers;

            return ContractHandler.SendRequestAsync(makeExternalCallsFunction);
        }

        public Task<TransactionReceipt> MakeExternalCallsRequestAndWaitForReceiptAsync(List<string> externalCallTargets,
            List<byte[]> externalCallDataList, List<string> refundTokens, List<string> refundReceivers,
            CancellationTokenSource cancellationToken = null)
        {
            var makeExternalCallsFunction = new MakeExternalCallsFunction();
            makeExternalCallsFunction.ExternalCallTargets = externalCallTargets;
            makeExternalCallsFunction.ExternalCallDataList = externalCallDataList;
            makeExternalCallsFunction.RefundTokens = refundTokens;
            makeExternalCallsFunction.RefundReceivers = refundReceivers;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(makeExternalCallsFunction, cancellationToken);
        }

        public Task<string> MulticallRequestAsync(MulticallFunction multicallFunction)
        {
            return ContractHandler.SendRequestAsync(multicallFunction);
        }

        public Task<TransactionReceipt> MulticallRequestAndWaitForReceiptAsync(MulticallFunction multicallFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(multicallFunction, cancellationToken);
        }

        public Task<string> MulticallRequestAsync(List<byte[]> data)
        {
            var multicallFunction = new MulticallFunction();
            multicallFunction.Data = data;

            return ContractHandler.SendRequestAsync(multicallFunction);
        }

        public Task<TransactionReceipt> MulticallRequestAndWaitForReceiptAsync(List<byte[]> data,
            CancellationTokenSource cancellationToken = null)
        {
            var multicallFunction = new MulticallFunction();
            multicallFunction.Data = data;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(multicallFunction, cancellationToken);
        }

        public Task<string> OrderHandlerQueryAsync(OrderHandlerFunction orderHandlerFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<OrderHandlerFunction, string>(orderHandlerFunction, blockParameter);
        }


        public Task<string> OrderHandlerQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<OrderHandlerFunction, string>(null, blockParameter);
        }

        public Task<string> RoleStoreQueryAsync(RoleStoreFunction roleStoreFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<RoleStoreFunction, string>(roleStoreFunction, blockParameter);
        }


        public Task<string> RoleStoreQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<RoleStoreFunction, string>(null, blockParameter);
        }

        public Task<string> RouterQueryAsync(RouterFunction routerFunction, BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<RouterFunction, string>(routerFunction, blockParameter);
        }


        public Task<string> RouterQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<RouterFunction, string>(null, blockParameter);
        }

        public Task<string> SendNativeTokenRequestAsync(SendNativeTokenFunction sendNativeTokenFunction)
        {
            return ContractHandler.SendRequestAsync(sendNativeTokenFunction);
        }

        public Task<TransactionReceipt> SendNativeTokenRequestAndWaitForReceiptAsync(
            SendNativeTokenFunction sendNativeTokenFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(sendNativeTokenFunction, cancellationToken);
        }

        public Task<string> SendNativeTokenRequestAsync(string receiver, BigInteger amount)
        {
            var sendNativeTokenFunction = new SendNativeTokenFunction();
            sendNativeTokenFunction.Receiver = receiver;
            sendNativeTokenFunction.Amount = amount;

            return ContractHandler.SendRequestAsync(sendNativeTokenFunction);
        }

        public Task<TransactionReceipt> SendNativeTokenRequestAndWaitForReceiptAsync(string receiver, BigInteger amount,
            CancellationTokenSource cancellationToken = null)
        {
            var sendNativeTokenFunction = new SendNativeTokenFunction();
            sendNativeTokenFunction.Receiver = receiver;
            sendNativeTokenFunction.Amount = amount;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(sendNativeTokenFunction, cancellationToken);
        }

        public Task<string> SendTokensRequestAsync(SendTokensFunction sendTokensFunction)
        {
            return ContractHandler.SendRequestAsync(sendTokensFunction);
        }

        public Task<TransactionReceipt> SendTokensRequestAndWaitForReceiptAsync(SendTokensFunction sendTokensFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(sendTokensFunction, cancellationToken);
        }

        public Task<string> SendTokensRequestAsync(string token, string receiver, BigInteger amount)
        {
            var sendTokensFunction = new SendTokensFunction();
            sendTokensFunction.Token = token;
            sendTokensFunction.Receiver = receiver;
            sendTokensFunction.Amount = amount;

            return ContractHandler.SendRequestAsync(sendTokensFunction);
        }

        public Task<TransactionReceipt> SendTokensRequestAndWaitForReceiptAsync(string token, string receiver,
            BigInteger amount, CancellationTokenSource cancellationToken = null)
        {
            var sendTokensFunction = new SendTokensFunction();
            sendTokensFunction.Token = token;
            sendTokensFunction.Receiver = receiver;
            sendTokensFunction.Amount = amount;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(sendTokensFunction, cancellationToken);
        }

        public Task<string> SendWntRequestAsync(SendWntFunction sendWntFunction)
        {
            return ContractHandler.SendRequestAsync(sendWntFunction);
        }

        public Task<TransactionReceipt> SendWntRequestAndWaitForReceiptAsync(SendWntFunction sendWntFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(sendWntFunction, cancellationToken);
        }

        public Task<string> SendWntRequestAsync(string receiver, BigInteger amount)
        {
            var sendWntFunction = new SendWntFunction();
            sendWntFunction.Receiver = receiver;
            sendWntFunction.Amount = amount;

            return ContractHandler.SendRequestAsync(sendWntFunction);
        }

        public Task<TransactionReceipt> SendWntRequestAndWaitForReceiptAsync(string receiver, BigInteger amount,
            CancellationTokenSource cancellationToken = null)
        {
            var sendWntFunction = new SendWntFunction();
            sendWntFunction.Receiver = receiver;
            sendWntFunction.Amount = amount;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(sendWntFunction, cancellationToken);
        }

        public Task<string> SetSavedCallbackContractRequestAsync(
            SetSavedCallbackContractFunction setSavedCallbackContractFunction)
        {
            return ContractHandler.SendRequestAsync(setSavedCallbackContractFunction);
        }

        public Task<TransactionReceipt> SetSavedCallbackContractRequestAndWaitForReceiptAsync(
            SetSavedCallbackContractFunction setSavedCallbackContractFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(setSavedCallbackContractFunction,
                cancellationToken);
        }

        public Task<string> SetSavedCallbackContractRequestAsync(string market, string callbackContract)
        {
            var setSavedCallbackContractFunction = new SetSavedCallbackContractFunction();
            setSavedCallbackContractFunction.Market = market;
            setSavedCallbackContractFunction.CallbackContract = callbackContract;

            return ContractHandler.SendRequestAsync(setSavedCallbackContractFunction);
        }

        public Task<TransactionReceipt> SetSavedCallbackContractRequestAndWaitForReceiptAsync(string market,
            string callbackContract, CancellationTokenSource cancellationToken = null)
        {
            var setSavedCallbackContractFunction = new SetSavedCallbackContractFunction();
            setSavedCallbackContractFunction.Market = market;
            setSavedCallbackContractFunction.CallbackContract = callbackContract;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(setSavedCallbackContractFunction,
                cancellationToken);
        }

        public Task<string> SetUiFeeFactorRequestAsync(SetUiFeeFactorFunction setUiFeeFactorFunction)
        {
            return ContractHandler.SendRequestAsync(setUiFeeFactorFunction);
        }

        public Task<TransactionReceipt> SetUiFeeFactorRequestAndWaitForReceiptAsync(
            SetUiFeeFactorFunction setUiFeeFactorFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(setUiFeeFactorFunction, cancellationToken);
        }

        public Task<string> SetUiFeeFactorRequestAsync(BigInteger uiFeeFactor)
        {
            var setUiFeeFactorFunction = new SetUiFeeFactorFunction();
            setUiFeeFactorFunction.UiFeeFactor = uiFeeFactor;

            return ContractHandler.SendRequestAsync(setUiFeeFactorFunction);
        }

        public Task<TransactionReceipt> SetUiFeeFactorRequestAndWaitForReceiptAsync(BigInteger uiFeeFactor,
            CancellationTokenSource cancellationToken = null)
        {
            var setUiFeeFactorFunction = new SetUiFeeFactorFunction();
            setUiFeeFactorFunction.UiFeeFactor = uiFeeFactor;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(setUiFeeFactorFunction, cancellationToken);
        }

        public Task<string> ShiftHandlerQueryAsync(ShiftHandlerFunction shiftHandlerFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<ShiftHandlerFunction, string>(shiftHandlerFunction, blockParameter);
        }


        public Task<string> ShiftHandlerQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<ShiftHandlerFunction, string>(null, blockParameter);
        }

        public Task<string> SimulateExecuteDepositRequestAsync(
            SimulateExecuteDepositFunction simulateExecuteDepositFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteDepositFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteDepositRequestAndWaitForReceiptAsync(
            SimulateExecuteDepositFunction simulateExecuteDepositFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteDepositFunction, cancellationToken);
        }

        public Task<string> SimulateExecuteDepositRequestAsync(byte[] key, SimulatePricesParams simulatedOracleParams)
        {
            var simulateExecuteDepositFunction = new SimulateExecuteDepositFunction();
            simulateExecuteDepositFunction.Key = key;
            simulateExecuteDepositFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAsync(simulateExecuteDepositFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteDepositRequestAndWaitForReceiptAsync(byte[] key,
            SimulatePricesParams simulatedOracleParams, CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteDepositFunction = new SimulateExecuteDepositFunction();
            simulateExecuteDepositFunction.Key = key;
            simulateExecuteDepositFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteDepositFunction, cancellationToken);
        }

        public Task<string> SimulateExecuteLatestDepositRequestAsync(
            SimulateExecuteLatestDepositFunction simulateExecuteLatestDepositFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteLatestDepositFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestDepositRequestAndWaitForReceiptAsync(
            SimulateExecuteLatestDepositFunction simulateExecuteLatestDepositFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestDepositFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteLatestDepositRequestAsync(SimulatePricesParams simulatedOracleParams)
        {
            var simulateExecuteLatestDepositFunction = new SimulateExecuteLatestDepositFunction();
            simulateExecuteLatestDepositFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAsync(simulateExecuteLatestDepositFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestDepositRequestAndWaitForReceiptAsync(
            SimulatePricesParams simulatedOracleParams, CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteLatestDepositFunction = new SimulateExecuteLatestDepositFunction();
            simulateExecuteLatestDepositFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestDepositFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteLatestOrderRequestAsync(
            SimulateExecuteLatestOrderFunction simulateExecuteLatestOrderFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteLatestOrderFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestOrderRequestAndWaitForReceiptAsync(
            SimulateExecuteLatestOrderFunction simulateExecuteLatestOrderFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestOrderFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteLatestOrderRequestAsync(SimulatePricesParams simulatedOracleParams)
        {
            var simulateExecuteLatestOrderFunction = new SimulateExecuteLatestOrderFunction();
            simulateExecuteLatestOrderFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAsync(simulateExecuteLatestOrderFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestOrderRequestAndWaitForReceiptAsync(
            SimulatePricesParams simulatedOracleParams, CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteLatestOrderFunction = new SimulateExecuteLatestOrderFunction();
            simulateExecuteLatestOrderFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestOrderFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteLatestShiftRequestAsync(
            SimulateExecuteLatestShiftFunction simulateExecuteLatestShiftFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteLatestShiftFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestShiftRequestAndWaitForReceiptAsync(
            SimulateExecuteLatestShiftFunction simulateExecuteLatestShiftFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestShiftFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteLatestShiftRequestAsync(SimulatePricesParams simulatedOracleParams)
        {
            var simulateExecuteLatestShiftFunction = new SimulateExecuteLatestShiftFunction();
            simulateExecuteLatestShiftFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAsync(simulateExecuteLatestShiftFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestShiftRequestAndWaitForReceiptAsync(
            SimulatePricesParams simulatedOracleParams, CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteLatestShiftFunction = new SimulateExecuteLatestShiftFunction();
            simulateExecuteLatestShiftFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestShiftFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteLatestWithdrawalRequestAsync(
            SimulateExecuteLatestWithdrawalFunction simulateExecuteLatestWithdrawalFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteLatestWithdrawalFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestWithdrawalRequestAndWaitForReceiptAsync(
            SimulateExecuteLatestWithdrawalFunction simulateExecuteLatestWithdrawalFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestWithdrawalFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteLatestWithdrawalRequestAsync(SimulatePricesParams simulatedOracleParams,
            byte swapPricingType)
        {
            var simulateExecuteLatestWithdrawalFunction = new SimulateExecuteLatestWithdrawalFunction();
            simulateExecuteLatestWithdrawalFunction.SimulatedOracleParams = simulatedOracleParams;
            simulateExecuteLatestWithdrawalFunction.SwapPricingType = swapPricingType;

            return ContractHandler.SendRequestAsync(simulateExecuteLatestWithdrawalFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteLatestWithdrawalRequestAndWaitForReceiptAsync(
            SimulatePricesParams simulatedOracleParams, byte swapPricingType,
            CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteLatestWithdrawalFunction = new SimulateExecuteLatestWithdrawalFunction();
            simulateExecuteLatestWithdrawalFunction.SimulatedOracleParams = simulatedOracleParams;
            simulateExecuteLatestWithdrawalFunction.SwapPricingType = swapPricingType;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteLatestWithdrawalFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteOrderRequestAsync(SimulateExecuteOrderFunction simulateExecuteOrderFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteOrderFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteOrderRequestAndWaitForReceiptAsync(
            SimulateExecuteOrderFunction simulateExecuteOrderFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteOrderFunction, cancellationToken);
        }

        public Task<string> SimulateExecuteOrderRequestAsync(byte[] key, SimulatePricesParams simulatedOracleParams)
        {
            var simulateExecuteOrderFunction = new SimulateExecuteOrderFunction();
            simulateExecuteOrderFunction.Key = key;
            simulateExecuteOrderFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAsync(simulateExecuteOrderFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteOrderRequestAndWaitForReceiptAsync(byte[] key,
            SimulatePricesParams simulatedOracleParams, CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteOrderFunction = new SimulateExecuteOrderFunction();
            simulateExecuteOrderFunction.Key = key;
            simulateExecuteOrderFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteOrderFunction, cancellationToken);
        }

        public Task<string> SimulateExecuteShiftRequestAsync(SimulateExecuteShiftFunction simulateExecuteShiftFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteShiftFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteShiftRequestAndWaitForReceiptAsync(
            SimulateExecuteShiftFunction simulateExecuteShiftFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteShiftFunction, cancellationToken);
        }

        public Task<string> SimulateExecuteShiftRequestAsync(byte[] key, SimulatePricesParams simulatedOracleParams)
        {
            var simulateExecuteShiftFunction = new SimulateExecuteShiftFunction();
            simulateExecuteShiftFunction.Key = key;
            simulateExecuteShiftFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAsync(simulateExecuteShiftFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteShiftRequestAndWaitForReceiptAsync(byte[] key,
            SimulatePricesParams simulatedOracleParams, CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteShiftFunction = new SimulateExecuteShiftFunction();
            simulateExecuteShiftFunction.Key = key;
            simulateExecuteShiftFunction.SimulatedOracleParams = simulatedOracleParams;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteShiftFunction, cancellationToken);
        }

        public Task<string> SimulateExecuteWithdrawalRequestAsync(
            SimulateExecuteWithdrawalFunction simulateExecuteWithdrawalFunction)
        {
            return ContractHandler.SendRequestAsync(simulateExecuteWithdrawalFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteWithdrawalRequestAndWaitForReceiptAsync(
            SimulateExecuteWithdrawalFunction simulateExecuteWithdrawalFunction,
            CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteWithdrawalFunction,
                cancellationToken);
        }

        public Task<string> SimulateExecuteWithdrawalRequestAsync(byte[] key,
            SimulatePricesParams simulatedOracleParams, byte swapPricingType)
        {
            var simulateExecuteWithdrawalFunction = new SimulateExecuteWithdrawalFunction();
            simulateExecuteWithdrawalFunction.Key = key;
            simulateExecuteWithdrawalFunction.SimulatedOracleParams = simulatedOracleParams;
            simulateExecuteWithdrawalFunction.SwapPricingType = swapPricingType;

            return ContractHandler.SendRequestAsync(simulateExecuteWithdrawalFunction);
        }

        public Task<TransactionReceipt> SimulateExecuteWithdrawalRequestAndWaitForReceiptAsync(byte[] key,
            SimulatePricesParams simulatedOracleParams, byte swapPricingType,
            CancellationTokenSource cancellationToken = null)
        {
            var simulateExecuteWithdrawalFunction = new SimulateExecuteWithdrawalFunction();
            simulateExecuteWithdrawalFunction.Key = key;
            simulateExecuteWithdrawalFunction.SimulatedOracleParams = simulatedOracleParams;
            simulateExecuteWithdrawalFunction.SwapPricingType = swapPricingType;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(simulateExecuteWithdrawalFunction,
                cancellationToken);
        }

        public Task<string> UpdateOrderRequestAsync(UpdateOrderFunction updateOrderFunction)
        {
            return ContractHandler.SendRequestAsync(updateOrderFunction);
        }

        public Task<TransactionReceipt> UpdateOrderRequestAndWaitForReceiptAsync(
            UpdateOrderFunction updateOrderFunction, CancellationTokenSource cancellationToken = null)
        {
            return ContractHandler.SendRequestAndWaitForReceiptAsync(updateOrderFunction, cancellationToken);
        }

        public Task<string> UpdateOrderRequestAsync(byte[] key, BigInteger sizeDeltaUsd, BigInteger acceptablePrice,
            BigInteger triggerPrice, BigInteger minOutputAmount, BigInteger validFromTime, bool autoCancel)
        {
            var updateOrderFunction = new UpdateOrderFunction();
            updateOrderFunction.Key = key;
            updateOrderFunction.SizeDeltaUsd = sizeDeltaUsd;
            updateOrderFunction.AcceptablePrice = acceptablePrice;
            updateOrderFunction.TriggerPrice = triggerPrice;
            updateOrderFunction.MinOutputAmount = minOutputAmount;
            updateOrderFunction.ValidFromTime = validFromTime;
            updateOrderFunction.AutoCancel = autoCancel;

            return ContractHandler.SendRequestAsync(updateOrderFunction);
        }

        public Task<TransactionReceipt> UpdateOrderRequestAndWaitForReceiptAsync(byte[] key, BigInteger sizeDeltaUsd,
            BigInteger acceptablePrice, BigInteger triggerPrice, BigInteger minOutputAmount, BigInteger validFromTime,
            bool autoCancel, CancellationTokenSource cancellationToken = null)
        {
            var updateOrderFunction = new UpdateOrderFunction();
            updateOrderFunction.Key = key;
            updateOrderFunction.SizeDeltaUsd = sizeDeltaUsd;
            updateOrderFunction.AcceptablePrice = acceptablePrice;
            updateOrderFunction.TriggerPrice = triggerPrice;
            updateOrderFunction.MinOutputAmount = minOutputAmount;
            updateOrderFunction.ValidFromTime = validFromTime;
            updateOrderFunction.AutoCancel = autoCancel;

            return ContractHandler.SendRequestAndWaitForReceiptAsync(updateOrderFunction, cancellationToken);
        }

        public Task<string> WithdrawalHandlerQueryAsync(WithdrawalHandlerFunction withdrawalHandlerFunction,
            BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<WithdrawalHandlerFunction, string>(withdrawalHandlerFunction,
                blockParameter);
        }


        public Task<string> WithdrawalHandlerQueryAsync(BlockParameter blockParameter = null)
        {
            return ContractHandler.QueryAsync<WithdrawalHandlerFunction, string>(null, blockParameter);
        }

        public override List<Type> GetAllFunctionTypes()
        {
            return new List<Type>
            {
                typeof(CancelDepositFunction),
                typeof(CancelOrderFunction),
                typeof(CancelShiftFunction),
                typeof(CancelWithdrawalFunction),
                typeof(ClaimAffiliateRewardsFunction),
                typeof(ClaimCollateralFunction),
                typeof(ClaimFundingFeesFunction),
                typeof(ClaimUiFeesFunction),
                typeof(CreateDepositFunction),
                typeof(CreateOrderFunction),
                typeof(CreateShiftFunction),
                typeof(CreateWithdrawalFunction),
                typeof(DataStoreFunction),
                typeof(DepositHandlerFunction),
                typeof(EventEmitterFunction),
                typeof(ExecuteAtomicWithdrawalFunction),
                typeof(ExternalHandlerFunction),
                typeof(MakeExternalCallsFunction),
                typeof(MulticallFunction),
                typeof(OrderHandlerFunction),
                typeof(RoleStoreFunction),
                typeof(RouterFunction),
                typeof(SendNativeTokenFunction),
                typeof(SendTokensFunction),
                typeof(SendWntFunction),
                typeof(SetSavedCallbackContractFunction),
                typeof(SetUiFeeFactorFunction),
                typeof(ShiftHandlerFunction),
                typeof(SimulateExecuteDepositFunction),
                typeof(SimulateExecuteLatestDepositFunction),
                typeof(SimulateExecuteLatestOrderFunction),
                typeof(SimulateExecuteLatestShiftFunction),
                typeof(SimulateExecuteLatestWithdrawalFunction),
                typeof(SimulateExecuteOrderFunction),
                typeof(SimulateExecuteShiftFunction),
                typeof(SimulateExecuteWithdrawalFunction),
                typeof(UpdateOrderFunction),
                typeof(WithdrawalHandlerFunction)
            };
        }

        public override List<Type> GetAllEventTypes()
        {
            return new List<Type>
            {
            };
        }

        public override List<Type> GetAllErrorTypes()
        {
            return new List<Type>
            {
                typeof(CollateralAlreadyClaimedError),
                typeof(DisabledFeatureError),
                typeof(DisabledMarketError),
                typeof(EmptyAddressInMarketTokenBalanceValidationError),
                typeof(EmptyDepositError),
                typeof(EmptyHoldingAddressError),
                typeof(EmptyMarketError),
                typeof(EmptyOrderError),
                typeof(EmptyReceiverError),
                typeof(EmptyTokenTranferGasLimitError),
                typeof(InvalidClaimAffiliateRewardsInputError),
                typeof(InvalidClaimCollateralInputError),
                typeof(InvalidClaimFundingFeesInputError),
                typeof(InvalidClaimUiFeesInputError),
                typeof(InvalidClaimableFactorError),
                typeof(InvalidMarketTokenBalanceError),
                typeof(InvalidMarketTokenBalanceForClaimableFundingError),
                typeof(InvalidMarketTokenBalanceForCollateralAmountError),
                typeof(InvalidUiFeeFactorError),
                typeof(TokenTransferErrorError),
                typeof(UnauthorizedError)
            };
        }
    }
}