Keep3r.cs

using System;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Numerics;
using Nethereum.Hex.HexTypes;
using Nethereum.ABI.FunctionEncoding.Attributes;
using Nethereum.Web3;
using Nethereum.RPC.Eth.DTOs;
using Nethereum.Contracts.CQS;
using Nethereum.Contracts;
using System.Threading;

namespace Keep3r
{


    public class KeeperConsole
    {
        public static async Task Main()
        {
            var url = "https://mainnet.infura.io/v3/7238211010344719ad14a89db874158c";
            var privateKey = "0x7580e7fb49df1c861f0050fae31c2224c6aba908e116b8da44ee8cd927b990b0";
            var account = new Nethereum.Web3.Accounts.Account(privateKey);
            var web3 = new Web3(account, url);

              var contractAddress = "0x1cEB5cB57C4D4E2b2433641b95Dd330A33185A44";
            var contractHandler = web3.Eth.GetContractHandler(contractAddress);
            /** Function: getJobs**/
            
            var getJobsFunctionReturn = await contractHandler.QueryAsync<GetJobsFunction, List<string>>();
            foreach(var job in getJobsFunctionReturn)
            {
                Console.WriteLine(job);
            }

            /** Function: BASE**/
            /*
            var bASEFunctionReturn = await contractHandler.QueryAsync<BASEFunction, BigInteger>();
            */


            /** Function: BOND**/
            /*
            var bONDFunctionReturn = await contractHandler.QueryAsync<BONDFunction, BigInteger>();
            */


            /** Function: DELEGATION_TYPEHASH**/
            /*
            var dELEGATION_TYPEHASHFunctionReturn = await contractHandler.QueryAsync<DELEGATION_TYPEHASHFunction, byte[]>();
            */


            /** Function: DOMAINSEPARATOR**/
            /*
            var dOMAINSEPARATORFunctionReturn = await contractHandler.QueryAsync<DOMAINSEPARATORFunction, byte[]>();
            */


            /** Function: DOMAIN_TYPEHASH**/
            /*
            var dOMAIN_TYPEHASHFunctionReturn = await contractHandler.QueryAsync<DOMAIN_TYPEHASHFunction, byte[]>();
            */


            /** Function: ETH**/
            /*
            var eTHFunctionReturn = await contractHandler.QueryAsync<ETHFunction, string>();
            */


            /** Function: FEE**/
            /*
            var fEEFunctionReturn = await contractHandler.QueryAsync<FEEFunction, BigInteger>();
            */


            /** Function: KPRH**/
            /*
            var kPRHFunctionReturn = await contractHandler.QueryAsync<KPRHFunction, string>();
            */


            /** Function: LIQUIDITYBOND**/
            /*
            var lIQUIDITYBONDFunctionReturn = await contractHandler.QueryAsync<LIQUIDITYBONDFunction, BigInteger>();
            */


            /** Function: PERMIT_TYPEHASH**/
            /*
            var pERMIT_TYPEHASHFunctionReturn = await contractHandler.QueryAsync<PERMIT_TYPEHASHFunction, byte[]>();
            */


            /** Function: UNBOND**/
            /*
            var uNBONDFunctionReturn = await contractHandler.QueryAsync<UNBONDFunction, BigInteger>();
            */


            /** Function: acceptGovernance**/
            /*
            var acceptGovernanceFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync<AcceptGovernanceFunction>();
            */


            /** Function: activate**/
            /*
            var activateFunction = new ActivateFunction();
            activateFunction.Bonding = bonding;
            var activateFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(activateFunction);
            */


            /** Function: addCredit**/
            /*
            var addCreditFunction = new AddCreditFunction();
            addCreditFunction.Credit = credit;
            addCreditFunction.Job = job;
            addCreditFunction.Amount = amount;
            var addCreditFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(addCreditFunction);
            */


            /** Function: addCreditETH**/
            /*
            var addCreditETHFunction = new AddCreditETHFunction();
            addCreditETHFunction.Job = job;
            var addCreditETHFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(addCreditETHFunction);
            */


            /** Function: addJob**/
            /*
            var addJobFunction = new AddJobFunction();
            addJobFunction.Job = job;
            var addJobFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(addJobFunction);
            */


            /** Function: addKPRCredit**/
            /*
            var addKPRCreditFunction = new AddKPRCreditFunction();
            addKPRCreditFunction.Job = job;
            addKPRCreditFunction.Amount = amount;
            var addKPRCreditFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(addKPRCreditFunction);
            */


            /** Function: addLiquidityToJob**/
            /*
            var addLiquidityToJobFunction = new AddLiquidityToJobFunction();
            addLiquidityToJobFunction.Liquidity = liquidity;
            addLiquidityToJobFunction.Job = job;
            addLiquidityToJobFunction.Amount = amount;
            var addLiquidityToJobFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(addLiquidityToJobFunction);
            */


            /** Function: addVotes**/
            /*
            var addVotesFunction = new AddVotesFunction();
            addVotesFunction.Voter = voter;
            addVotesFunction.Amount = amount;
            var addVotesFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(addVotesFunction);
            */


            /** Function: allowance**/
            /*
            var allowanceFunction = new AllowanceFunction();
            allowanceFunction.Account = account;
            allowanceFunction.Spender = spender;
            var allowanceFunctionReturn = await contractHandler.QueryAsync<AllowanceFunction, BigInteger>(allowanceFunction);
            */


            /** Function: applyCreditToJob**/
            /*
            var applyCreditToJobFunction = new ApplyCreditToJobFunction();
            applyCreditToJobFunction.Provider = provider;
            applyCreditToJobFunction.Liquidity = liquidity;
            applyCreditToJobFunction.Job = job;
            var applyCreditToJobFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(applyCreditToJobFunction);
            */


            /** Function: approve**/
            /*
            var approveFunction = new ApproveFunction();
            approveFunction.Spender = spender;
            approveFunction.Amount = amount;
            var approveFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(approveFunction);
            */


            /** Function: approveLiquidity**/
            /*
            var approveLiquidityFunction = new ApproveLiquidityFunction();
            approveLiquidityFunction.Liquidity = liquidity;
            var approveLiquidityFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(approveLiquidityFunction);
            */


            /** Function: balanceOf**/
            /*
            var balanceOfFunction = new BalanceOfFunction();
            balanceOfFunction.Account = account;
            var balanceOfFunctionReturn = await contractHandler.QueryAsync<BalanceOfFunction, BigInteger>(balanceOfFunction);
            */


            /** Function: blacklist**/
            /*
            var blacklistFunction = new BlacklistFunction();
            blacklistFunction.ReturnValue1 = returnValue1;
            var blacklistFunctionReturn = await contractHandler.QueryAsync<BlacklistFunction, bool>(blacklistFunction);
            */


            /** Function: bond**/
            /*
            var bondFunction = new BondFunction();
            bondFunction.Bonding = bonding;
            bondFunction.Amount = amount;
            var bondFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(bondFunction);
            */


            /** Function: bondings**/
            /*
            var bondingsFunction = new BondingsFunction();
            bondingsFunction.ReturnValue1 = returnValue1;
            bondingsFunction.ReturnValue2 = returnValue2;
            var bondingsFunctionReturn = await contractHandler.QueryAsync<BondingsFunction, BigInteger>(bondingsFunction);
            */


            /** Function: bonds**/
            /*
            var bondsFunction = new BondsFunction();
            bondsFunction.ReturnValue1 = returnValue1;
            bondsFunction.ReturnValue2 = returnValue2;
            var bondsFunctionReturn = await contractHandler.QueryAsync<BondsFunction, BigInteger>(bondsFunction);
            */


            /** Function: burn**/
            /*
            var burnFunction = new BurnFunction();
            burnFunction.Amount = amount;
            var burnFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(burnFunction);
            */


            /** Function: checkpoints**/
            /*
            var checkpointsFunction = new CheckpointsFunction(); 
            checkpointsFunction.ReturnValue1 = returnValue1;
            checkpointsFunction.ReturnValue2 = returnValue2;
            var checkpointsOutputDTO = await contractHandler.QueryDeserializingToObjectAsync<CheckpointsFunction, CheckpointsOutputDTO>(checkpointsFunction);
            */


            /** Function: credits**/
            /*
            var creditsFunction = new CreditsFunction();
            creditsFunction.ReturnValue1 = returnValue1;
            creditsFunction.ReturnValue2 = returnValue2;
            var creditsFunctionReturn = await contractHandler.QueryAsync<CreditsFunction, BigInteger>(creditsFunction);
            */


            /** Function: decimals**/
            /*
            var decimalsFunctionReturn = await contractHandler.QueryAsync<DecimalsFunction, byte>();
            */


            /** Function: delegate**/
            /*
            var delegateFunction = new DelegateFunction();
            delegateFunction.Delegatee = delegatee;
            var delegateFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(delegateFunction);
            */


            /** Function: delegateBySig**/
            /*
            var delegateBySigFunction = new DelegateBySigFunction();
            delegateBySigFunction.Delegatee = delegatee;
            delegateBySigFunction.Nonce = nonce;
            delegateBySigFunction.Expiry = expiry;
            delegateBySigFunction.V = v;
            delegateBySigFunction.R = r;
            delegateBySigFunction.S = s;
            var delegateBySigFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(delegateBySigFunction);
            */


            /** Function: delegates**/
            /*
            var delegatesFunction = new DelegatesFunction();
            delegatesFunction.ReturnValue1 = returnValue1;
            var delegatesFunctionReturn = await contractHandler.QueryAsync<DelegatesFunction, string>(delegatesFunction);
            */


            /** Function: dispute**/
            /*
            var disputeFunction = new DisputeFunction();
            disputeFunction.Keeper = keeper;
            var disputeFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(disputeFunction);
            */


            /** Function: disputes**/
            /*
            var disputesFunction = new DisputesFunction();
            disputesFunction.ReturnValue1 = returnValue1;
            var disputesFunctionReturn = await contractHandler.QueryAsync<DisputesFunction, bool>(disputesFunction);
            */


            /** Function: firstSeen**/
            /*
            var firstSeenFunction = new FirstSeenFunction();
            firstSeenFunction.ReturnValue1 = returnValue1;
            var firstSeenFunctionReturn = await contractHandler.QueryAsync<FirstSeenFunction, BigInteger>(firstSeenFunction);
            */


            /** Function: getCurrentVotes**/
            /*
            var getCurrentVotesFunction = new GetCurrentVotesFunction();
            getCurrentVotesFunction.Account = account;
            var getCurrentVotesFunctionReturn = await contractHandler.QueryAsync<GetCurrentVotesFunction, BigInteger>(getCurrentVotesFunction);
            */





            /** Function: getKeepers**/
            /*
            var getKeepersFunctionReturn = await contractHandler.QueryAsync<GetKeepersFunction, List<string>>();
            */


            /** Function: getPriorVotes**/
            /*
            var getPriorVotesFunction = new GetPriorVotesFunction();
            getPriorVotesFunction.Account = account;
            getPriorVotesFunction.BlockNumber = blockNumber;
            var getPriorVotesFunctionReturn = await contractHandler.QueryAsync<GetPriorVotesFunction, BigInteger>(getPriorVotesFunction);
            */


            /** Function: governance**/
            /*
            var governanceFunctionReturn = await contractHandler.QueryAsync<GovernanceFunction, string>();
            */


            /** Function: isBondedKeeper**/
            /*
            var isBondedKeeperFunction = new IsBondedKeeperFunction();
            isBondedKeeperFunction.Keeper = keeper;
            isBondedKeeperFunction.Bond = bond;
            isBondedKeeperFunction.MinBond = minBond;
            isBondedKeeperFunction.Earned = earned;
            isBondedKeeperFunction.Age = age;
            var isBondedKeeperFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(isBondedKeeperFunction);
            */


            /** Function: isKeeper**/
            /*
            var isKeeperFunction = new IsKeeperFunction();
            isKeeperFunction.Keeper = keeper;
            var isKeeperFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(isKeeperFunction);
            */


            /** Function: isMinKeeper**/
            /*
            var isMinKeeperFunction = new IsMinKeeperFunction();
            isMinKeeperFunction.Keeper = keeper;
            isMinKeeperFunction.MinBond = minBond;
            isMinKeeperFunction.Earned = earned;
            isMinKeeperFunction.Age = age;
            var isMinKeeperFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(isMinKeeperFunction);
            */


            /** Function: jobList**/
            /*
            var jobListFunction = new JobListFunction();
            jobListFunction.ReturnValue1 = returnValue1;
            var jobListFunctionReturn = await contractHandler.QueryAsync<JobListFunction, string>(jobListFunction);
            */


            /** Function: jobProposalDelay**/
            /*
            var jobProposalDelayFunction = new JobProposalDelayFunction();
            jobProposalDelayFunction.ReturnValue1 = returnValue1;
            var jobProposalDelayFunctionReturn = await contractHandler.QueryAsync<JobProposalDelayFunction, BigInteger>(jobProposalDelayFunction);
            */


            /** Function: jobs**/
            /*
            var jobsFunction = new JobsFunction();
            jobsFunction.ReturnValue1 = returnValue1;
            var jobsFunctionReturn = await contractHandler.QueryAsync<JobsFunction, bool>(jobsFunction);
            */


            /** Function: keeperList**/
            /*
            var keeperListFunction = new KeeperListFunction();
            keeperListFunction.ReturnValue1 = returnValue1;
            var keeperListFunctionReturn = await contractHandler.QueryAsync<KeeperListFunction, string>(keeperListFunction);
            */


            /** Function: keepers**/
            /*
            var keepersFunction = new KeepersFunction();
            keepersFunction.ReturnValue1 = returnValue1;
            var keepersFunctionReturn = await contractHandler.QueryAsync<KeepersFunction, bool>(keepersFunction);
            */


            /** Function: lastJob**/
            /*
            var lastJobFunction = new LastJobFunction();
            lastJobFunction.ReturnValue1 = returnValue1;
            var lastJobFunctionReturn = await contractHandler.QueryAsync<LastJobFunction, BigInteger>(lastJobFunction);
            */


            /** Function: liquidityAccepted**/
            /*
            var liquidityAcceptedFunction = new LiquidityAcceptedFunction();
            liquidityAcceptedFunction.ReturnValue1 = returnValue1;
            var liquidityAcceptedFunctionReturn = await contractHandler.QueryAsync<LiquidityAcceptedFunction, bool>(liquidityAcceptedFunction);
            */


            /** Function: liquidityAmount**/
            /*
            var liquidityAmountFunction = new LiquidityAmountFunction();
            liquidityAmountFunction.ReturnValue1 = returnValue1;
            liquidityAmountFunction.ReturnValue2 = returnValue2;
            liquidityAmountFunction.ReturnValue3 = returnValue3;
            var liquidityAmountFunctionReturn = await contractHandler.QueryAsync<LiquidityAmountFunction, BigInteger>(liquidityAmountFunction);
            */


            /** Function: liquidityAmountsUnbonding**/
            /*
            var liquidityAmountsUnbondingFunction = new LiquidityAmountsUnbondingFunction();
            liquidityAmountsUnbondingFunction.ReturnValue1 = returnValue1;
            liquidityAmountsUnbondingFunction.ReturnValue2 = returnValue2;
            liquidityAmountsUnbondingFunction.ReturnValue3 = returnValue3;
            var liquidityAmountsUnbondingFunctionReturn = await contractHandler.QueryAsync<LiquidityAmountsUnbondingFunction, BigInteger>(liquidityAmountsUnbondingFunction);
            */


            /** Function: liquidityApplied**/
            /*
            var liquidityAppliedFunction = new LiquidityAppliedFunction();
            liquidityAppliedFunction.ReturnValue1 = returnValue1;
            liquidityAppliedFunction.ReturnValue2 = returnValue2;
            liquidityAppliedFunction.ReturnValue3 = returnValue3;
            var liquidityAppliedFunctionReturn = await contractHandler.QueryAsync<LiquidityAppliedFunction, BigInteger>(liquidityAppliedFunction);
            */


            /** Function: liquidityPairs**/
            /*
            var liquidityPairsFunction = new LiquidityPairsFunction();
            liquidityPairsFunction.ReturnValue1 = returnValue1;
            var liquidityPairsFunctionReturn = await contractHandler.QueryAsync<LiquidityPairsFunction, string>(liquidityPairsFunction);
            */


            /** Function: liquidityProvided**/
            /*
            var liquidityProvidedFunction = new LiquidityProvidedFunction();
            liquidityProvidedFunction.ReturnValue1 = returnValue1;
            liquidityProvidedFunction.ReturnValue2 = returnValue2;
            liquidityProvidedFunction.ReturnValue3 = returnValue3;
            var liquidityProvidedFunctionReturn = await contractHandler.QueryAsync<LiquidityProvidedFunction, BigInteger>(liquidityProvidedFunction);
            */


            /** Function: liquidityUnbonding**/
            /*
            var liquidityUnbondingFunction = new LiquidityUnbondingFunction();
            liquidityUnbondingFunction.ReturnValue1 = returnValue1;
            liquidityUnbondingFunction.ReturnValue2 = returnValue2;
            liquidityUnbondingFunction.ReturnValue3 = returnValue3;
            var liquidityUnbondingFunctionReturn = await contractHandler.QueryAsync<LiquidityUnbondingFunction, BigInteger>(liquidityUnbondingFunction);
            */


            /** Function: mint**/
            /*
            var mintFunction = new MintFunction();
            mintFunction.Amount = amount;
            var mintFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(mintFunction);
            */


            /** Function: name**/
            /*
            var nameFunctionReturn = await contractHandler.QueryAsync<NameFunction, string>();
            */


            /** Function: nonces**/
            /*
            var noncesFunction = new NoncesFunction();
            noncesFunction.ReturnValue1 = returnValue1;
            var noncesFunctionReturn = await contractHandler.QueryAsync<NoncesFunction, BigInteger>(noncesFunction);
            */


            /** Function: numCheckpoints**/
            /*
            var numCheckpointsFunction = new NumCheckpointsFunction();
            numCheckpointsFunction.ReturnValue1 = returnValue1;
            var numCheckpointsFunctionReturn = await contractHandler.QueryAsync<NumCheckpointsFunction, uint>(numCheckpointsFunction);
            */


            /** Function: pairs**/
            /*
            var pairsFunctionReturn = await contractHandler.QueryAsync<PairsFunction, List<string>>();
            */


            /** Function: partialUnbonding**/
            /*
            var partialUnbondingFunction = new PartialUnbondingFunction();
            partialUnbondingFunction.ReturnValue1 = returnValue1;
            partialUnbondingFunction.ReturnValue2 = returnValue2;
            var partialUnbondingFunctionReturn = await contractHandler.QueryAsync<PartialUnbondingFunction, BigInteger>(partialUnbondingFunction);
            */


            /** Function: pendingGovernance**/
            /*
            var pendingGovernanceFunctionReturn = await contractHandler.QueryAsync<PendingGovernanceFunction, string>();
            */


            /** Function: pendingbonds**/
            /*
            var pendingbondsFunction = new PendingbondsFunction();
            pendingbondsFunction.ReturnValue1 = returnValue1;
            pendingbondsFunction.ReturnValue2 = returnValue2;
            var pendingbondsFunctionReturn = await contractHandler.QueryAsync<PendingbondsFunction, BigInteger>(pendingbondsFunction);
            */


            /** Function: permit**/
            /*
            var permitFunction = new PermitFunction();
            permitFunction.Owner = owner;
            permitFunction.Spender = spender;
            permitFunction.Amount = amount;
            permitFunction.Deadline = deadline;
            permitFunction.V = v;
            permitFunction.R = r;
            permitFunction.S = s;
            var permitFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(permitFunction);
            */


            /** Function: receipt**/
            /*
            var receiptFunction = new ReceiptFunction();
            receiptFunction.Credit = credit;
            receiptFunction.Keeper = keeper;
            receiptFunction.Amount = amount;
            var receiptFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(receiptFunction);
            */


            /** Function: receiptETH**/
            /*
            var receiptETHFunction = new ReceiptETHFunction();
            receiptETHFunction.Keeper = keeper;
            receiptETHFunction.Amount = amount;
            var receiptETHFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(receiptETHFunction);
            */


            /** Function: removeJob**/
            /*
            var removeJobFunction = new RemoveJobFunction();
            removeJobFunction.Job = job;
            var removeJobFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(removeJobFunction);
            */


            /** Function: removeLiquidityFromJob**/
            /*
            var removeLiquidityFromJobFunction = new RemoveLiquidityFromJobFunction();
            removeLiquidityFromJobFunction.Liquidity = liquidity;
            removeLiquidityFromJobFunction.Job = job;
            var removeLiquidityFromJobFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(removeLiquidityFromJobFunction);
            */


            /** Function: removeVotes**/
            /*
            var removeVotesFunction = new RemoveVotesFunction();
            removeVotesFunction.Voter = voter;
            removeVotesFunction.Amount = amount;
            var removeVotesFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(removeVotesFunction);
            */


            /** Function: resolve**/
            /*
            var resolveFunction = new ResolveFunction();
            resolveFunction.Keeper = keeper;
            var resolveFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(resolveFunction);
            */


            /** Function: revoke**/
            /*
            var revokeFunction = new RevokeFunction();
            revokeFunction.Keeper = keeper;
            var revokeFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(revokeFunction);
            */


            /** Function: revokeLiquidity**/
            /*
            var revokeLiquidityFunction = new RevokeLiquidityFunction();
            revokeLiquidityFunction.Liquidity = liquidity;
            var revokeLiquidityFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(revokeLiquidityFunction);
            */


            /** Function: setGovernance**/
            /*
            var setGovernanceFunction = new SetGovernanceFunction();
            setGovernanceFunction.Governance = governance;
            var setGovernanceFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(setGovernanceFunction);
            */


            /** Function: setKeep3rHelper**/
            /*
            var setKeep3rHelperFunction = new SetKeep3rHelperFunction();
            setKeep3rHelperFunction.Kprh = kprh;
            var setKeep3rHelperFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(setKeep3rHelperFunction);
            */


            /** Function: slash**/
            /*
            var slashFunction = new SlashFunction();
            slashFunction.Bonded = bonded;
            slashFunction.Keeper = keeper;
            slashFunction.Amount = amount;
            var slashFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(slashFunction);
            */


            /** Function: symbol**/
            /*
            var symbolFunctionReturn = await contractHandler.QueryAsync<SymbolFunction, string>();
            */


            /** Function: totalBonded**/
            /*
            var totalBondedFunctionReturn = await contractHandler.QueryAsync<TotalBondedFunction, BigInteger>();
            */


            /** Function: totalSupply**/
            /*
            var totalSupplyFunctionReturn = await contractHandler.QueryAsync<TotalSupplyFunction, BigInteger>();
            */


            /** Function: transfer**/
            /*
            var transferFunction = new TransferFunction();
            transferFunction.Dst = dst;
            transferFunction.Amount = amount;
            var transferFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(transferFunction);
            */


            /** Function: transferFrom**/
            /*
            var transferFromFunction = new TransferFromFunction();
            transferFromFunction.Src = src;
            transferFromFunction.Dst = dst;
            transferFromFunction.Amount = amount;
            var transferFromFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(transferFromFunction);
            */


            /** Function: unbond**/
            /*
            var unbondFunction = new UnbondFunction();
            unbondFunction.Bonding = bonding;
            unbondFunction.Amount = amount;
            var unbondFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(unbondFunction);
            */


            /** Function: unbondLiquidityFromJob**/
            /*
            var unbondLiquidityFromJobFunction = new UnbondLiquidityFromJobFunction();
            unbondLiquidityFromJobFunction.Liquidity = liquidity;
            unbondLiquidityFromJobFunction.Job = job;
            unbondLiquidityFromJobFunction.Amount = amount;
            var unbondLiquidityFromJobFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(unbondLiquidityFromJobFunction);
            */


            /** Function: unbondings**/
            /*
            var unbondingsFunction = new UnbondingsFunction();
            unbondingsFunction.ReturnValue1 = returnValue1;
            unbondingsFunction.ReturnValue2 = returnValue2;
            var unbondingsFunctionReturn = await contractHandler.QueryAsync<UnbondingsFunction, BigInteger>(unbondingsFunction);
            */


            /** Function: votes**/
            /*
            var votesFunction = new VotesFunction();
            votesFunction.ReturnValue1 = returnValue1;
            var votesFunctionReturn = await contractHandler.QueryAsync<VotesFunction, BigInteger>(votesFunction);
            */


            /** Function: withdraw**/
            /*
            var withdrawFunction = new WithdrawFunction();
            withdrawFunction.Bonding = bonding;
            var withdrawFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(withdrawFunction);
            */


            /** Function: workCompleted**/
            /*
            var workCompletedFunction = new WorkCompletedFunction();
            workCompletedFunction.ReturnValue1 = returnValue1;
            var workCompletedFunctionReturn = await contractHandler.QueryAsync<WorkCompletedFunction, BigInteger>(workCompletedFunction);
            */


            /** Function: workReceipt**/
            /*
            var workReceiptFunction = new WorkReceiptFunction();
            workReceiptFunction.Keeper = keeper;
            workReceiptFunction.Amount = amount;
            var workReceiptFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(workReceiptFunction);
            */


            /** Function: worked**/
            /*
            var workedFunction = new WorkedFunction();
            workedFunction.Keeper = keeper;
            var workedFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(workedFunction);
            */
        }

    }

    public partial class KeeperDeployment : KeeperDeploymentBase
    {
        public KeeperDeployment() : base(BYTECODE) { }
        public KeeperDeployment(string byteCode) : base(byteCode) { }
    }

    public class KeeperDeploymentBase : ContractDeploymentMessage
    {
        public static string BYTECODE = "";
        public KeeperDeploymentBase() : base(BYTECODE) { }
        public KeeperDeploymentBase(string byteCode) : base(byteCode) { }
        [Parameter("address", "_kph", 1)]
        public virtual string Kph { get; set; }
    }

    public partial class BASEFunction : BASEFunctionBase { }

    [Function("BASE", "uint256")]
    public class BASEFunctionBase : FunctionMessage
    {

    }

    public partial class BONDFunction : BONDFunctionBase { }

    [Function("BOND", "uint256")]
    public class BONDFunctionBase : FunctionMessage
    {

    }

    public partial class DELEGATION_TYPEHASHFunction : DELEGATION_TYPEHASHFunctionBase { }

    [Function("DELEGATION_TYPEHASH", "bytes32")]
    public class DELEGATION_TYPEHASHFunctionBase : FunctionMessage
    {

    }

    public partial class DOMAINSEPARATORFunction : DOMAINSEPARATORFunctionBase { }

    [Function("DOMAINSEPARATOR", "bytes32")]
    public class DOMAINSEPARATORFunctionBase : FunctionMessage
    {

    }

    public partial class DOMAIN_TYPEHASHFunction : DOMAIN_TYPEHASHFunctionBase { }

    [Function("DOMAIN_TYPEHASH", "bytes32")]
    public class DOMAIN_TYPEHASHFunctionBase : FunctionMessage
    {

    }

    public partial class ETHFunction : ETHFunctionBase { }

    [Function("ETH", "address")]
    public class ETHFunctionBase : FunctionMessage
    {

    }

    public partial class FEEFunction : FEEFunctionBase { }

    [Function("FEE", "uint256")]
    public class FEEFunctionBase : FunctionMessage
    {

    }

    public partial class KPRHFunction : KPRHFunctionBase { }

    [Function("KPRH", "address")]
    public class KPRHFunctionBase : FunctionMessage
    {

    }

    public partial class LIQUIDITYBONDFunction : LIQUIDITYBONDFunctionBase { }

    [Function("LIQUIDITYBOND", "uint256")]
    public class LIQUIDITYBONDFunctionBase : FunctionMessage
    {

    }

    public partial class PERMIT_TYPEHASHFunction : PERMIT_TYPEHASHFunctionBase { }

    [Function("PERMIT_TYPEHASH", "bytes32")]
    public class PERMIT_TYPEHASHFunctionBase : FunctionMessage
    {

    }

    public partial class UNBONDFunction : UNBONDFunctionBase { }

    [Function("UNBOND", "uint256")]
    public class UNBONDFunctionBase : FunctionMessage
    {

    }

    public partial class AcceptGovernanceFunction : AcceptGovernanceFunctionBase { }

    [Function("acceptGovernance")]
    public class AcceptGovernanceFunctionBase : FunctionMessage
    {

    }

    public partial class ActivateFunction : ActivateFunctionBase { }

    [Function("activate")]
    public class ActivateFunctionBase : FunctionMessage
    {
        [Parameter("address", "bonding", 1)]
        public virtual string Bonding { get; set; }
    }

    public partial class AddCreditFunction : AddCreditFunctionBase { }

    [Function("addCredit")]
    public class AddCreditFunctionBase : FunctionMessage
    {
        [Parameter("address", "credit", 1)]
        public virtual string Credit { get; set; }
        [Parameter("address", "job", 2)]
        public virtual string Job { get; set; }
        [Parameter("uint256", "amount", 3)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class AddCreditETHFunction : AddCreditETHFunctionBase { }

    [Function("addCreditETH")]
    public class AddCreditETHFunctionBase : FunctionMessage
    {
        [Parameter("address", "job", 1)]
        public virtual string Job { get; set; }
    }

    public partial class AddJobFunction : AddJobFunctionBase { }

    [Function("addJob")]
    public class AddJobFunctionBase : FunctionMessage
    {
        [Parameter("address", "job", 1)]
        public virtual string Job { get; set; }
    }

    public partial class AddKPRCreditFunction : AddKPRCreditFunctionBase { }

    [Function("addKPRCredit")]
    public class AddKPRCreditFunctionBase : FunctionMessage
    {
        [Parameter("address", "job", 1)]
        public virtual string Job { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class AddLiquidityToJobFunction : AddLiquidityToJobFunctionBase { }

    [Function("addLiquidityToJob")]
    public class AddLiquidityToJobFunctionBase : FunctionMessage
    {
        [Parameter("address", "liquidity", 1)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "job", 2)]
        public virtual string Job { get; set; }
        [Parameter("uint256", "amount", 3)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class AddVotesFunction : AddVotesFunctionBase { }

    [Function("addVotes")]
    public class AddVotesFunctionBase : FunctionMessage
    {
        [Parameter("address", "voter", 1)]
        public virtual string Voter { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class AllowanceFunction : AllowanceFunctionBase { }

    [Function("allowance", "uint256")]
    public class AllowanceFunctionBase : FunctionMessage
    {
        [Parameter("address", "account", 1)]
        public virtual string Account { get; set; }
        [Parameter("address", "spender", 2)]
        public virtual string Spender { get; set; }
    }

    public partial class ApplyCreditToJobFunction : ApplyCreditToJobFunctionBase { }

    [Function("applyCreditToJob")]
    public class ApplyCreditToJobFunctionBase : FunctionMessage
    {
        [Parameter("address", "provider", 1)]
        public virtual string Provider { get; set; }
        [Parameter("address", "liquidity", 2)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "job", 3)]
        public virtual string Job { get; set; }
    }

    public partial class ApproveFunction : ApproveFunctionBase { }

    [Function("approve", "bool")]
    public class ApproveFunctionBase : FunctionMessage
    {
        [Parameter("address", "spender", 1)]
        public virtual string Spender { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class ApproveLiquidityFunction : ApproveLiquidityFunctionBase { }

    [Function("approveLiquidity")]
    public class ApproveLiquidityFunctionBase : FunctionMessage
    {
        [Parameter("address", "liquidity", 1)]
        public virtual string Liquidity { get; set; }
    }

    public partial class BalanceOfFunction : BalanceOfFunctionBase { }

    [Function("balanceOf", "uint256")]
    public class BalanceOfFunctionBase : FunctionMessage
    {
        [Parameter("address", "account", 1)]
        public virtual string Account { get; set; }
    }

    public partial class BlacklistFunction : BlacklistFunctionBase { }

    [Function("blacklist", "bool")]
    public class BlacklistFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class BondFunction : BondFunctionBase { }

    [Function("bond")]
    public class BondFunctionBase : FunctionMessage
    {
        [Parameter("address", "bonding", 1)]
        public virtual string Bonding { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class BondingsFunction : BondingsFunctionBase { }

    [Function("bondings", "uint256")]
    public class BondingsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
    }

    public partial class BondsFunction : BondsFunctionBase { }

    [Function("bonds", "uint256")]
    public class BondsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
    }

    public partial class BurnFunction : BurnFunctionBase { }

    [Function("burn")]
    public class BurnFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "amount", 1)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class CheckpointsFunction : CheckpointsFunctionBase { }

    [Function("checkpoints", typeof(CheckpointsOutputDTO))]
    public class CheckpointsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("uint32", "", 2)]
        public virtual uint ReturnValue2 { get; set; }
    }

    public partial class CreditsFunction : CreditsFunctionBase { }

    [Function("credits", "uint256")]
    public class CreditsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
    }

    public partial class DecimalsFunction : DecimalsFunctionBase { }

    [Function("decimals", "uint8")]
    public class DecimalsFunctionBase : FunctionMessage
    {

    }

    public partial class DelegateFunction : DelegateFunctionBase { }

    [Function("delegate")]
    public class DelegateFunctionBase : FunctionMessage
    {
        [Parameter("address", "delegatee", 1)]
        public virtual string Delegatee { get; set; }
    }

    public partial class DelegateBySigFunction : DelegateBySigFunctionBase { }

    [Function("delegateBySig")]
    public class DelegateBySigFunctionBase : FunctionMessage
    {
        [Parameter("address", "delegatee", 1)]
        public virtual string Delegatee { get; set; }
        [Parameter("uint256", "nonce", 2)]
        public virtual BigInteger Nonce { get; set; }
        [Parameter("uint256", "expiry", 3)]
        public virtual BigInteger Expiry { get; set; }
        [Parameter("uint8", "v", 4)]
        public virtual byte V { get; set; }
        [Parameter("bytes32", "r", 5)]
        public virtual byte[] R { get; set; }
        [Parameter("bytes32", "s", 6)]
        public virtual byte[] S { get; set; }
    }

    public partial class DelegatesFunction : DelegatesFunctionBase { }

    [Function("delegates", "address")]
    public class DelegatesFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class DisputeFunction : DisputeFunctionBase { }

    [Function("dispute")]
    public class DisputeFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
    }

    public partial class DisputesFunction : DisputesFunctionBase { }

    [Function("disputes", "bool")]
    public class DisputesFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class FirstSeenFunction : FirstSeenFunctionBase { }

    [Function("firstSeen", "uint256")]
    public class FirstSeenFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class GetCurrentVotesFunction : GetCurrentVotesFunctionBase { }

    [Function("getCurrentVotes", "uint256")]
    public class GetCurrentVotesFunctionBase : FunctionMessage
    {
        [Parameter("address", "account", 1)]
        public virtual string Account { get; set; }
    }

    public partial class GetJobsFunction : GetJobsFunctionBase { }

    [Function("getJobs", "address[]")]
    public class GetJobsFunctionBase : FunctionMessage
    {

    }

    public partial class GetKeepersFunction : GetKeepersFunctionBase { }

    [Function("getKeepers", "address[]")]
    public class GetKeepersFunctionBase : FunctionMessage
    {

    }

    public partial class GetPriorVotesFunction : GetPriorVotesFunctionBase { }

    [Function("getPriorVotes", "uint256")]
    public class GetPriorVotesFunctionBase : FunctionMessage
    {
        [Parameter("address", "account", 1)]
        public virtual string Account { get; set; }
        [Parameter("uint256", "blockNumber", 2)]
        public virtual BigInteger BlockNumber { get; set; }
    }

    public partial class GovernanceFunction : GovernanceFunctionBase { }

    [Function("governance", "address")]
    public class GovernanceFunctionBase : FunctionMessage
    {

    }

    public partial class IsBondedKeeperFunction : IsBondedKeeperFunctionBase { }

    [Function("isBondedKeeper", "bool")]
    public class IsBondedKeeperFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
        [Parameter("address", "bond", 2)]
        public virtual string Bond { get; set; }
        [Parameter("uint256", "minBond", 3)]
        public virtual BigInteger MinBond { get; set; }
        [Parameter("uint256", "earned", 4)]
        public virtual BigInteger Earned { get; set; }
        [Parameter("uint256", "age", 5)]
        public virtual BigInteger Age { get; set; }
    }

    public partial class IsKeeperFunction : IsKeeperFunctionBase { }

    [Function("isKeeper", "bool")]
    public class IsKeeperFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
    }

    public partial class IsMinKeeperFunction : IsMinKeeperFunctionBase { }

    [Function("isMinKeeper", "bool")]
    public class IsMinKeeperFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "minBond", 2)]
        public virtual BigInteger MinBond { get; set; }
        [Parameter("uint256", "earned", 3)]
        public virtual BigInteger Earned { get; set; }
        [Parameter("uint256", "age", 4)]
        public virtual BigInteger Age { get; set; }
    }

    public partial class JobListFunction : JobListFunctionBase { }

    [Function("jobList", "address")]
    public class JobListFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class JobProposalDelayFunction : JobProposalDelayFunctionBase { }

    [Function("jobProposalDelay", "uint256")]
    public class JobProposalDelayFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class JobsFunction : JobsFunctionBase { }

    [Function("jobs", "bool")]
    public class JobsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class KeeperListFunction : KeeperListFunctionBase { }

    [Function("keeperList", "address")]
    public class KeeperListFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class KeepersFunction : KeepersFunctionBase { }

    [Function("keepers", "bool")]
    public class KeepersFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class LastJobFunction : LastJobFunctionBase { }

    [Function("lastJob", "uint256")]
    public class LastJobFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class LiquidityAcceptedFunction : LiquidityAcceptedFunctionBase { }

    [Function("liquidityAccepted", "bool")]
    public class LiquidityAcceptedFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class LiquidityAmountFunction : LiquidityAmountFunctionBase { }

    [Function("liquidityAmount", "uint256")]
    public class LiquidityAmountFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
        [Parameter("address", "", 3)]
        public virtual string ReturnValue3 { get; set; }
    }

    public partial class LiquidityAmountsUnbondingFunction : LiquidityAmountsUnbondingFunctionBase { }

    [Function("liquidityAmountsUnbonding", "uint256")]
    public class LiquidityAmountsUnbondingFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
        [Parameter("address", "", 3)]
        public virtual string ReturnValue3 { get; set; }
    }

    public partial class LiquidityAppliedFunction : LiquidityAppliedFunctionBase { }

    [Function("liquidityApplied", "uint256")]
    public class LiquidityAppliedFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
        [Parameter("address", "", 3)]
        public virtual string ReturnValue3 { get; set; }
    }

    public partial class LiquidityPairsFunction : LiquidityPairsFunctionBase { }

    [Function("liquidityPairs", "address")]
    public class LiquidityPairsFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class LiquidityProvidedFunction : LiquidityProvidedFunctionBase { }

    [Function("liquidityProvided", "uint256")]
    public class LiquidityProvidedFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
        [Parameter("address", "", 3)]
        public virtual string ReturnValue3 { get; set; }
    }

    public partial class LiquidityUnbondingFunction : LiquidityUnbondingFunctionBase { }

    [Function("liquidityUnbonding", "uint256")]
    public class LiquidityUnbondingFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
        [Parameter("address", "", 3)]
        public virtual string ReturnValue3 { get; set; }
    }

    public partial class MintFunction : MintFunctionBase { }

    [Function("mint")]
    public class MintFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "amount", 1)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class NameFunction : NameFunctionBase { }

    [Function("name", "string")]
    public class NameFunctionBase : FunctionMessage
    {

    }

    public partial class NoncesFunction : NoncesFunctionBase { }

    [Function("nonces", "uint256")]
    public class NoncesFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class NumCheckpointsFunction : NumCheckpointsFunctionBase { }

    [Function("numCheckpoints", "uint32")]
    public class NumCheckpointsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class PairsFunction : PairsFunctionBase { }

    [Function("pairs", "address[]")]
    public class PairsFunctionBase : FunctionMessage
    {

    }

    public partial class PartialUnbondingFunction : PartialUnbondingFunctionBase { }

    [Function("partialUnbonding", "uint256")]
    public class PartialUnbondingFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
    }

    public partial class PendingGovernanceFunction : PendingGovernanceFunctionBase { }

    [Function("pendingGovernance", "address")]
    public class PendingGovernanceFunctionBase : FunctionMessage
    {

    }

    public partial class PendingbondsFunction : PendingbondsFunctionBase { }

    [Function("pendingbonds", "uint256")]
    public class PendingbondsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
    }

    public partial class PermitFunction : PermitFunctionBase { }

    [Function("permit")]
    public class PermitFunctionBase : FunctionMessage
    {
        [Parameter("address", "owner", 1)]
        public virtual string Owner { get; set; }
        [Parameter("address", "spender", 2)]
        public virtual string Spender { get; set; }
        [Parameter("uint256", "amount", 3)]
        public virtual BigInteger Amount { get; set; }
        [Parameter("uint256", "deadline", 4)]
        public virtual BigInteger Deadline { get; set; }
        [Parameter("uint8", "v", 5)]
        public virtual byte V { get; set; }
        [Parameter("bytes32", "r", 6)]
        public virtual byte[] R { get; set; }
        [Parameter("bytes32", "s", 7)]
        public virtual byte[] S { get; set; }
    }

    public partial class ReceiptFunction : ReceiptFunctionBase { }

    [Function("receipt")]
    public class ReceiptFunctionBase : FunctionMessage
    {
        [Parameter("address", "credit", 1)]
        public virtual string Credit { get; set; }
        [Parameter("address", "keeper", 2)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "amount", 3)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class ReceiptETHFunction : ReceiptETHFunctionBase { }

    [Function("receiptETH")]
    public class ReceiptETHFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class RemoveJobFunction : RemoveJobFunctionBase { }

    [Function("removeJob")]
    public class RemoveJobFunctionBase : FunctionMessage
    {
        [Parameter("address", "job", 1)]
        public virtual string Job { get; set; }
    }

    public partial class RemoveLiquidityFromJobFunction : RemoveLiquidityFromJobFunctionBase { }

    [Function("removeLiquidityFromJob")]
    public class RemoveLiquidityFromJobFunctionBase : FunctionMessage
    {
        [Parameter("address", "liquidity", 1)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "job", 2)]
        public virtual string Job { get; set; }
    }

    public partial class RemoveVotesFunction : RemoveVotesFunctionBase { }

    [Function("removeVotes")]
    public class RemoveVotesFunctionBase : FunctionMessage
    {
        [Parameter("address", "voter", 1)]
        public virtual string Voter { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class ResolveFunction : ResolveFunctionBase { }

    [Function("resolve")]
    public class ResolveFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
    }

    public partial class RevokeFunction : RevokeFunctionBase { }

    [Function("revoke")]
    public class RevokeFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
    }

    public partial class RevokeLiquidityFunction : RevokeLiquidityFunctionBase { }

    [Function("revokeLiquidity")]
    public class RevokeLiquidityFunctionBase : FunctionMessage
    {
        [Parameter("address", "liquidity", 1)]
        public virtual string Liquidity { get; set; }
    }

    public partial class SetGovernanceFunction : SetGovernanceFunctionBase { }

    [Function("setGovernance")]
    public class SetGovernanceFunctionBase : FunctionMessage
    {
        [Parameter("address", "_governance", 1)]
        public virtual string Governance { get; set; }
    }

    public partial class SetKeep3rHelperFunction : SetKeep3rHelperFunctionBase { }

    [Function("setKeep3rHelper")]
    public class SetKeep3rHelperFunctionBase : FunctionMessage
    {
        [Parameter("address", "_kprh", 1)]
        public virtual string Kprh { get; set; }
    }

    public partial class SlashFunction : SlashFunctionBase { }

    [Function("slash")]
    public class SlashFunctionBase : FunctionMessage
    {
        [Parameter("address", "bonded", 1)]
        public virtual string Bonded { get; set; }
        [Parameter("address", "keeper", 2)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "amount", 3)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class SymbolFunction : SymbolFunctionBase { }

    [Function("symbol", "string")]
    public class SymbolFunctionBase : FunctionMessage
    {

    }

    public partial class TotalBondedFunction : TotalBondedFunctionBase { }

    [Function("totalBonded", "uint256")]
    public class TotalBondedFunctionBase : FunctionMessage
    {

    }

    public partial class TotalSupplyFunction : TotalSupplyFunctionBase { }

    [Function("totalSupply", "uint256")]
    public class TotalSupplyFunctionBase : FunctionMessage
    {

    }

    public partial class TransferFunction : TransferFunctionBase { }

    [Function("transfer", "bool")]
    public class TransferFunctionBase : FunctionMessage
    {
        [Parameter("address", "dst", 1)]
        public virtual string Dst { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class TransferFromFunction : TransferFromFunctionBase { }

    [Function("transferFrom", "bool")]
    public class TransferFromFunctionBase : FunctionMessage
    {
        [Parameter("address", "src", 1)]
        public virtual string Src { get; set; }
        [Parameter("address", "dst", 2)]
        public virtual string Dst { get; set; }
        [Parameter("uint256", "amount", 3)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class UnbondFunction : UnbondFunctionBase { }

    [Function("unbond")]
    public class UnbondFunctionBase : FunctionMessage
    {
        [Parameter("address", "bonding", 1)]
        public virtual string Bonding { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class UnbondLiquidityFromJobFunction : UnbondLiquidityFromJobFunctionBase { }

    [Function("unbondLiquidityFromJob")]
    public class UnbondLiquidityFromJobFunctionBase : FunctionMessage
    {
        [Parameter("address", "liquidity", 1)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "job", 2)]
        public virtual string Job { get; set; }
        [Parameter("uint256", "amount", 3)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class UnbondingsFunction : UnbondingsFunctionBase { }

    [Function("unbondings", "uint256")]
    public class UnbondingsFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { get; set; }
    }

    public partial class VotesFunction : VotesFunctionBase { }

    [Function("votes", "uint256")]
    public class VotesFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class WithdrawFunction : WithdrawFunctionBase { }

    [Function("withdraw")]
    public class WithdrawFunctionBase : FunctionMessage
    {
        [Parameter("address", "bonding", 1)]
        public virtual string Bonding { get; set; }
    }

    public partial class WorkCompletedFunction : WorkCompletedFunctionBase { }

    [Function("workCompleted", "uint256")]
    public class WorkCompletedFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class WorkReceiptFunction : WorkReceiptFunctionBase { }

    [Function("workReceipt")]
    public class WorkReceiptFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "amount", 2)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class WorkedFunction : WorkedFunctionBase { }

    [Function("worked")]
    public class WorkedFunctionBase : FunctionMessage
    {
        [Parameter("address", "keeper", 1)]
        public virtual string Keeper { get; set; }
    }

    public partial class AddCreditEventDTO : AddCreditEventDTOBase { }

    [Event("AddCredit")]
    public class AddCreditEventDTOBase : IEventDTO
    {
        [Parameter("address", "credit", 1, true)]
        public virtual string Credit { get; set; }
        [Parameter("address", "job", 2, true)]
        public virtual string Job { get; set; }
        [Parameter("address", "creditor", 3, true)]
        public virtual string Creditor { get; set; }
        [Parameter("uint256", "block", 4, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "amount", 5, false)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class ApplyCreditEventDTO : ApplyCreditEventDTOBase { }

    [Event("ApplyCredit")]
    public class ApplyCreditEventDTOBase : IEventDTO
    {
        [Parameter("address", "job", 1, true)]
        public virtual string Job { get; set; }
        [Parameter("address", "liquidity", 2, true)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "provider", 3, true)]
        public virtual string Provider { get; set; }
        [Parameter("uint256", "block", 4, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "credit", 5, false)]
        public virtual BigInteger Credit { get; set; }
    }

    public partial class ApprovalEventDTO : ApprovalEventDTOBase { }

    [Event("Approval")]
    public class ApprovalEventDTOBase : IEventDTO
    {
        [Parameter("address", "owner", 1, true)]
        public virtual string Owner { get; set; }
        [Parameter("address", "spender", 2, true)]
        public virtual string Spender { get; set; }
        [Parameter("uint256", "amount", 3, false)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class DelegateChangedEventDTO : DelegateChangedEventDTOBase { }

    [Event("DelegateChanged")]
    public class DelegateChangedEventDTOBase : IEventDTO
    {
        [Parameter("address", "delegator", 1, true)]
        public virtual string Delegator { get; set; }
        [Parameter("address", "fromDelegate", 2, true)]
        public virtual string FromDelegate { get; set; }
        [Parameter("address", "toDelegate", 3, true)]
        public virtual string ToDelegate { get; set; }
    }

    public partial class DelegateVotesChangedEventDTO : DelegateVotesChangedEventDTOBase { }

    [Event("DelegateVotesChanged")]
    public class DelegateVotesChangedEventDTOBase : IEventDTO
    {
        [Parameter("address", "delegate", 1, true)]
        public virtual string Delegate { get; set; }
        [Parameter("uint256", "previousBalance", 2, false)]
        public virtual BigInteger PreviousBalance { get; set; }
        [Parameter("uint256", "newBalance", 3, false)]
        public virtual BigInteger NewBalance { get; set; }
    }

    public partial class JobAddedEventDTO : JobAddedEventDTOBase { }

    [Event("JobAdded")]
    public class JobAddedEventDTOBase : IEventDTO
    {
        [Parameter("address", "job", 1, true)]
        public virtual string Job { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("address", "governance", 3, false)]
        public virtual string Governance { get; set; }
    }

    public partial class JobRemovedEventDTO : JobRemovedEventDTOBase { }

    [Event("JobRemoved")]
    public class JobRemovedEventDTOBase : IEventDTO
    {
        [Parameter("address", "job", 1, true)]
        public virtual string Job { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("address", "governance", 3, false)]
        public virtual string Governance { get; set; }
    }

    public partial class KeeperBondedEventDTO : KeeperBondedEventDTOBase { }

    [Event("KeeperBonded")]
    public class KeeperBondedEventDTOBase : IEventDTO
    {
        [Parameter("address", "keeper", 1, true)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "activated", 3, false)]
        public virtual BigInteger Activated { get; set; }
        [Parameter("uint256", "bond", 4, false)]
        public virtual BigInteger Bond { get; set; }
    }

    public partial class KeeperBondingEventDTO : KeeperBondingEventDTOBase { }

    [Event("KeeperBonding")]
    public class KeeperBondingEventDTOBase : IEventDTO
    {
        [Parameter("address", "keeper", 1, true)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "active", 3, false)]
        public virtual BigInteger Active { get; set; }
        [Parameter("uint256", "bond", 4, false)]
        public virtual BigInteger Bond { get; set; }
    }

    public partial class KeeperDisputeEventDTO : KeeperDisputeEventDTOBase { }

    [Event("KeeperDispute")]
    public class KeeperDisputeEventDTOBase : IEventDTO
    {
        [Parameter("address", "keeper", 1, true)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
    }

    public partial class KeeperResolvedEventDTO : KeeperResolvedEventDTOBase { }

    [Event("KeeperResolved")]
    public class KeeperResolvedEventDTOBase : IEventDTO
    {
        [Parameter("address", "keeper", 1, true)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
    }

    public partial class KeeperSlashedEventDTO : KeeperSlashedEventDTOBase { }

    [Event("KeeperSlashed")]
    public class KeeperSlashedEventDTOBase : IEventDTO
    {
        [Parameter("address", "keeper", 1, true)]
        public virtual string Keeper { get; set; }
        [Parameter("address", "slasher", 2, true)]
        public virtual string Slasher { get; set; }
        [Parameter("uint256", "block", 3, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "slash", 4, false)]
        public virtual BigInteger Slash { get; set; }
    }

    public partial class KeeperUnbondingEventDTO : KeeperUnbondingEventDTOBase { }

    [Event("KeeperUnbonding")]
    public class KeeperUnbondingEventDTOBase : IEventDTO
    {
        [Parameter("address", "keeper", 1, true)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "deactive", 3, false)]
        public virtual BigInteger Deactive { get; set; }
        [Parameter("uint256", "bond", 4, false)]
        public virtual BigInteger Bond { get; set; }
    }

    public partial class KeeperUnboundEventDTO : KeeperUnboundEventDTOBase { }

    [Event("KeeperUnbound")]
    public class KeeperUnboundEventDTOBase : IEventDTO
    {
        [Parameter("address", "keeper", 1, true)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "block", 2, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "deactivated", 3, false)]
        public virtual BigInteger Deactivated { get; set; }
        [Parameter("uint256", "bond", 4, false)]
        public virtual BigInteger Bond { get; set; }
    }

    public partial class KeeperWorkedEventDTO : KeeperWorkedEventDTOBase { }

    [Event("KeeperWorked")]
    public class KeeperWorkedEventDTOBase : IEventDTO
    {
        [Parameter("address", "credit", 1, true)]
        public virtual string Credit { get; set; }
        [Parameter("address", "job", 2, true)]
        public virtual string Job { get; set; }
        [Parameter("address", "keeper", 3, true)]
        public virtual string Keeper { get; set; }
        [Parameter("uint256", "block", 4, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "amount", 5, false)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class RemoveJobEventDTO : RemoveJobEventDTOBase { }

    [Event("RemoveJob")]
    public class RemoveJobEventDTOBase : IEventDTO
    {
        [Parameter("address", "job", 1, true)]
        public virtual string Job { get; set; }
        [Parameter("address", "liquidity", 2, true)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "provider", 3, true)]
        public virtual string Provider { get; set; }
        [Parameter("uint256", "block", 4, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "credit", 5, false)]
        public virtual BigInteger Credit { get; set; }
    }

    public partial class SubmitJobEventDTO : SubmitJobEventDTOBase { }

    [Event("SubmitJob")]
    public class SubmitJobEventDTOBase : IEventDTO
    {
        [Parameter("address", "job", 1, true)]
        public virtual string Job { get; set; }
        [Parameter("address", "liquidity", 2, true)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "provider", 3, true)]
        public virtual string Provider { get; set; }
        [Parameter("uint256", "block", 4, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "credit", 5, false)]
        public virtual BigInteger Credit { get; set; }
    }

    public partial class TransferEventDTO : TransferEventDTOBase { }

    [Event("Transfer")]
    public class TransferEventDTOBase : IEventDTO
    {
        [Parameter("address", "from", 1, true)]
        public virtual string From { get; set; }
        [Parameter("address", "to", 2, true)]
        public virtual string To { get; set; }
        [Parameter("uint256", "amount", 3, false)]
        public virtual BigInteger Amount { get; set; }
    }

    public partial class UnbondJobEventDTO : UnbondJobEventDTOBase { }

    [Event("UnbondJob")]
    public class UnbondJobEventDTOBase : IEventDTO
    {
        [Parameter("address", "job", 1, true)]
        public virtual string Job { get; set; }
        [Parameter("address", "liquidity", 2, true)]
        public virtual string Liquidity { get; set; }
        [Parameter("address", "provider", 3, true)]
        public virtual string Provider { get; set; }
        [Parameter("uint256", "block", 4, false)]
        public virtual BigInteger Block { get; set; }
        [Parameter("uint256", "credit", 5, false)]
        public virtual BigInteger Credit { get; set; }
    }

    public partial class BASEOutputDTO : BASEOutputDTOBase { }

    [FunctionOutput]
    public class BASEOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class BONDOutputDTO : BONDOutputDTOBase { }

    [FunctionOutput]
    public class BONDOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class DELEGATION_TYPEHASHOutputDTO : DELEGATION_TYPEHASHOutputDTOBase { }

    [FunctionOutput]
    public class DELEGATION_TYPEHASHOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class DOMAINSEPARATOROutputDTO : DOMAINSEPARATOROutputDTOBase { }

    [FunctionOutput]
    public class DOMAINSEPARATOROutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class DOMAIN_TYPEHASHOutputDTO : DOMAIN_TYPEHASHOutputDTOBase { }

    [FunctionOutput]
    public class DOMAIN_TYPEHASHOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class ETHOutputDTO : ETHOutputDTOBase { }

    [FunctionOutput]
    public class ETHOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class FEEOutputDTO : FEEOutputDTOBase { }

    [FunctionOutput]
    public class FEEOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class KPRHOutputDTO : KPRHOutputDTOBase { }

    [FunctionOutput]
    public class KPRHOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class LIQUIDITYBONDOutputDTO : LIQUIDITYBONDOutputDTOBase { }

    [FunctionOutput]
    public class LIQUIDITYBONDOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class PERMIT_TYPEHASHOutputDTO : PERMIT_TYPEHASHOutputDTOBase { }

    [FunctionOutput]
    public class PERMIT_TYPEHASHOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bytes32", "", 1)]
        public virtual byte[] ReturnValue1 { get; set; }
    }

    public partial class UNBONDOutputDTO : UNBONDOutputDTOBase { }

    [FunctionOutput]
    public class UNBONDOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

















    public partial class AllowanceOutputDTO : AllowanceOutputDTOBase { }

    [FunctionOutput]
    public class AllowanceOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }







    public partial class BalanceOfOutputDTO : BalanceOfOutputDTOBase { }

    [FunctionOutput]
    public class BalanceOfOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class BlacklistOutputDTO : BlacklistOutputDTOBase { }

    [FunctionOutput]
    public class BlacklistOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }



    public partial class BondingsOutputDTO : BondingsOutputDTOBase { }

    [FunctionOutput]
    public class BondingsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class BondsOutputDTO : BondsOutputDTOBase { }

    [FunctionOutput]
    public class BondsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }



    public partial class CheckpointsOutputDTO : CheckpointsOutputDTOBase { }

    [FunctionOutput]
    public class CheckpointsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint32", "fromBlock", 1)]
        public virtual uint FromBlock { get; set; }
        [Parameter("uint256", "votes", 2)]
        public virtual BigInteger Votes { get; set; }
    }

    public partial class CreditsOutputDTO : CreditsOutputDTOBase { }

    [FunctionOutput]
    public class CreditsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class DecimalsOutputDTO : DecimalsOutputDTOBase { }

    [FunctionOutput]
    public class DecimalsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint8", "", 1)]
        public virtual byte ReturnValue1 { get; set; }
    }





    public partial class DelegatesOutputDTO : DelegatesOutputDTOBase { }

    [FunctionOutput]
    public class DelegatesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }



    public partial class DisputesOutputDTO : DisputesOutputDTOBase { }

    [FunctionOutput]
    public class DisputesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class FirstSeenOutputDTO : FirstSeenOutputDTOBase { }

    [FunctionOutput]
    public class FirstSeenOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GetCurrentVotesOutputDTO : GetCurrentVotesOutputDTOBase { }

    [FunctionOutput]
    public class GetCurrentVotesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GetJobsOutputDTO : GetJobsOutputDTOBase { }

    [FunctionOutput]
    public class GetJobsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address[]", "", 1)]
        public virtual List<string> ReturnValue1 { get; set; }
    }

    public partial class GetKeepersOutputDTO : GetKeepersOutputDTOBase { }

    [FunctionOutput]
    public class GetKeepersOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address[]", "", 1)]
        public virtual List<string> ReturnValue1 { get; set; }
    }

    public partial class GetPriorVotesOutputDTO : GetPriorVotesOutputDTOBase { }

    [FunctionOutput]
    public class GetPriorVotesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class GovernanceOutputDTO : GovernanceOutputDTOBase { }

    [FunctionOutput]
    public class GovernanceOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }







    public partial class JobListOutputDTO : JobListOutputDTOBase { }

    [FunctionOutput]
    public class JobListOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class JobProposalDelayOutputDTO : JobProposalDelayOutputDTOBase { }

    [FunctionOutput]
    public class JobProposalDelayOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class JobsOutputDTO : JobsOutputDTOBase { }

    [FunctionOutput]
    public class JobsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class KeeperListOutputDTO : KeeperListOutputDTOBase { }

    [FunctionOutput]
    public class KeeperListOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class KeepersOutputDTO : KeepersOutputDTOBase { }

    [FunctionOutput]
    public class KeepersOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class LastJobOutputDTO : LastJobOutputDTOBase { }

    [FunctionOutput]
    public class LastJobOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class LiquidityAcceptedOutputDTO : LiquidityAcceptedOutputDTOBase { }

    [FunctionOutput]
    public class LiquidityAcceptedOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("bool", "", 1)]
        public virtual bool ReturnValue1 { get; set; }
    }

    public partial class LiquidityAmountOutputDTO : LiquidityAmountOutputDTOBase { }

    [FunctionOutput]
    public class LiquidityAmountOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class LiquidityAmountsUnbondingOutputDTO : LiquidityAmountsUnbondingOutputDTOBase { }

    [FunctionOutput]
    public class LiquidityAmountsUnbondingOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class LiquidityAppliedOutputDTO : LiquidityAppliedOutputDTOBase { }

    [FunctionOutput]
    public class LiquidityAppliedOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class LiquidityPairsOutputDTO : LiquidityPairsOutputDTOBase { }

    [FunctionOutput]
    public class LiquidityPairsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class LiquidityProvidedOutputDTO : LiquidityProvidedOutputDTOBase { }

    [FunctionOutput]
    public class LiquidityProvidedOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class LiquidityUnbondingOutputDTO : LiquidityUnbondingOutputDTOBase { }

    [FunctionOutput]
    public class LiquidityUnbondingOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }



    public partial class NameOutputDTO : NameOutputDTOBase { }

    [FunctionOutput]
    public class NameOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("string", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class NoncesOutputDTO : NoncesOutputDTOBase { }

    [FunctionOutput]
    public class NoncesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class NumCheckpointsOutputDTO : NumCheckpointsOutputDTOBase { }

    [FunctionOutput]
    public class NumCheckpointsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint32", "", 1)]
        public virtual uint ReturnValue1 { get; set; }
    }

    public partial class PairsOutputDTO : PairsOutputDTOBase { }

    [FunctionOutput]
    public class PairsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address[]", "", 1)]
        public virtual List<string> ReturnValue1 { get; set; }
    }

    public partial class PartialUnbondingOutputDTO : PartialUnbondingOutputDTOBase { }

    [FunctionOutput]
    public class PartialUnbondingOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class PendingGovernanceOutputDTO : PendingGovernanceOutputDTOBase { }

    [FunctionOutput]
    public class PendingGovernanceOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class PendingbondsOutputDTO : PendingbondsOutputDTOBase { }

    [FunctionOutput]
    public class PendingbondsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

























    public partial class SymbolOutputDTO : SymbolOutputDTOBase { }

    [FunctionOutput]
    public class SymbolOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("string", "", 1)]
        public virtual string ReturnValue1 { get; set; }
    }

    public partial class TotalBondedOutputDTO : TotalBondedOutputDTOBase { }

    [FunctionOutput]
    public class TotalBondedOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class TotalSupplyOutputDTO : TotalSupplyOutputDTOBase { }

    [FunctionOutput]
    public class TotalSupplyOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }









    public partial class UnbondingsOutputDTO : UnbondingsOutputDTOBase { }

    [FunctionOutput]
    public class UnbondingsOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }

    public partial class VotesOutputDTO : VotesOutputDTOBase { }

    [FunctionOutput]
    public class VotesOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }



    public partial class WorkCompletedOutputDTO : WorkCompletedOutputDTOBase { }

    [FunctionOutput]
    public class WorkCompletedOutputDTOBase : IFunctionOutputDTO
    {
        [Parameter("uint256", "", 1)]
        public virtual BigInteger ReturnValue1 { get; set; }
    }


}