UniswapV2Pair.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 UniswapV2Pair
{

//Quick sample generated from etherscan https://etherscan.io/address/0xa5e79baee540f000ef6f23d067cd3ac22c7d9fe6#code
//using the abigen in the http://playground.nethereum.com
    public class UniswapV2PairConsole
    {
        public static async Task Main()
        {
            var web3 = new Web3("https://mainnet.infura.io/v3/7238211010344719ad14a89db874158c");
           
            
						var contractAddress = "0xa5E79baEe540f000ef6F23D067cd3AC22c7d9Fe6";
            var contractHandler = web3.Eth.GetContractHandler(contractAddress);

            
            /** Function: getReserves**/
          
            var getReservesOutputDTO = await contractHandler.QueryDeserializingToObjectAsync<GetReservesFunction, GetReservesOutputDTO>();
						Console.WriteLine(getReservesOutputDTO.Reserve0);
						Console.WriteLine(getReservesOutputDTO.Reserve1);
						Console.WriteLine(getReservesOutputDTO.BlockTimestampLast);

            /** Function: DOMAIN_SEPARATOR**/
            /*
            var dOMAIN_SEPARATORFunctionReturn = await contractHandler.QueryAsync<DOMAIN_SEPARATORFunction, byte[]>();
            */


            /** Function: MINIMUM_LIQUIDITY**/
            /*
            var mINIMUM_LIQUIDITYFunctionReturn = await contractHandler.QueryAsync<MINIMUM_LIQUIDITYFunction, BigInteger>();
            */


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


            /** Function: allowance**/
            /*
            var allowanceFunction = new AllowanceFunction();
            allowanceFunction.ReturnValue1 = returnValue1;
            allowanceFunction.ReturnValue2 = returnValue2;
            var allowanceFunctionReturn = await contractHandler.QueryAsync<AllowanceFunction, BigInteger>(allowanceFunction);
            */


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


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


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


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


            /** Function: factory**/
            /*
            var factoryFunctionReturn = await contractHandler.QueryAsync<FactoryFunction, string>();
            */



            /** Function: initialize**/
            /*
            var initializeFunction = new InitializeFunction();
            initializeFunction.Token0 = token0;
            initializeFunction.Token1 = token1;
            var initializeFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(initializeFunction);
            */


            /** Function: kLast**/
            /*
            var kLastFunctionReturn = await contractHandler.QueryAsync<KLastFunction, BigInteger>();
            */


            /** Function: mint**/
            /*
            var mintFunction = new MintFunction();
            mintFunction.To = to;
            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: permit**/
            /*
            var permitFunction = new PermitFunction();
            permitFunction.Owner = owner;
            permitFunction.Spender = spender;
            permitFunction.Value = value;
            permitFunction.Deadline = deadline;
            permitFunction.V = v;
            permitFunction.R = r;
            permitFunction.S = s;
            var permitFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(permitFunction);
            */


            /** Function: price0CumulativeLast**/
            /*
            var price0CumulativeLastFunctionReturn = await contractHandler.QueryAsync<Price0CumulativeLastFunction, BigInteger>();
            */


            /** Function: price1CumulativeLast**/
            /*
            var price1CumulativeLastFunctionReturn = await contractHandler.QueryAsync<Price1CumulativeLastFunction, BigInteger>();
            */


            /** Function: skim**/
            /*
            var skimFunction = new SkimFunction();
            skimFunction.To = to;
            var skimFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(skimFunction);
            */


            /** Function: swap**/
            /*
            var swapFunction = new SwapFunction();
            swapFunction.Amount0Out = amount0Out;
            swapFunction.Amount1Out = amount1Out;
            swapFunction.To = to;
            swapFunction.Data = data;
            var swapFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(swapFunction);
            */


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


            /** Function: sync**/
            /*
            var syncFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync<SyncFunction>();
            */


            /** Function: token0**/
            /*
            var token0FunctionReturn = await contractHandler.QueryAsync<Token0Function, string>();
            */


            /** Function: token1**/
            /*
            var token1FunctionReturn = await contractHandler.QueryAsync<Token1Function, string>();
            */


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


            /** Function: transfer**/
            /*
            var transferFunction = new TransferFunction();
            transferFunction.To = to;
            transferFunction.Value = value;
            var transferFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(transferFunction);
            */


            /** Function: transferFrom**/
            /*
            var transferFromFunction = new TransferFromFunction();
            transferFromFunction.From = from;
            transferFromFunction.To = to;
            transferFromFunction.Value = value;
            var transferFromFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(transferFromFunction);
            */
        }

    }

    public partial class UniswapV2PairDeployment : UniswapV2PairDeploymentBase
    {
        public UniswapV2PairDeployment() : base(BYTECODE) { }
        public UniswapV2PairDeployment(string byteCode) : base(byteCode) { }
    }

    public class UniswapV2PairDeploymentBase : ContractDeploymentMessage
    {
        public static string BYTECODE = "";
        public UniswapV2PairDeploymentBase() : base(BYTECODE) { }
        public UniswapV2PairDeploymentBase(string byteCode) : base(byteCode) { }

    }

    public partial class DOMAIN_SEPARATORFunction : DOMAIN_SEPARATORFunctionBase { }

    [Function("DOMAIN_SEPARATOR", "bytes32")]
    public class DOMAIN_SEPARATORFunctionBase : FunctionMessage
    {

    }

    public partial class MINIMUM_LIQUIDITYFunction : MINIMUM_LIQUIDITYFunctionBase { }

    [Function("MINIMUM_LIQUIDITY", "uint256")]
    public class MINIMUM_LIQUIDITYFunctionBase : FunctionMessage
    {

    }

    public partial class PERMIT_TYPEHASHFunction : PERMIT_TYPEHASHFunctionBase { }

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

    }

    public partial class AllowanceFunction : AllowanceFunctionBase { }

    [Function("allowance", "uint256")]
    public class AllowanceFunctionBase : FunctionMessage
    {
        [Parameter("address", "", 1)]
        public virtual string ReturnValue1 { get; set; }
        [Parameter("address", "", 2)]
        public virtual string ReturnValue2 { 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", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class BalanceOfFunction : BalanceOfFunctionBase { }

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

    public partial class BurnFunction : BurnFunctionBase { }

    [Function("burn", typeof(BurnOutputDTO))]
    public class BurnFunctionBase : FunctionMessage
    {
        [Parameter("address", "to", 1)]
        public virtual string To { get; set; }
    }

    public partial class DecimalsFunction : DecimalsFunctionBase { }

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

    }

    public partial class FactoryFunction : FactoryFunctionBase { }

    [Function("factory", "address")]
    public class FactoryFunctionBase : FunctionMessage
    {

    }

    public partial class GetReservesFunction : GetReservesFunctionBase { }

    [Function("getReserves", typeof(GetReservesOutputDTO))]
    public class GetReservesFunctionBase : FunctionMessage
    {

    }

    public partial class InitializeFunction : InitializeFunctionBase { }

    [Function("initialize")]
    public class InitializeFunctionBase : FunctionMessage
    {
        [Parameter("address", "_token0", 1)]
        public virtual string Token0 { get; set; }
        [Parameter("address", "_token1", 2)]
        public virtual string Token1 { get; set; }
    }

    public partial class KLastFunction : KLastFunctionBase { }

    [Function("kLast", "uint256")]
    public class KLastFunctionBase : FunctionMessage
    {

    }

    public partial class MintFunction : MintFunctionBase { }

    [Function("mint", "uint256")]
    public class MintFunctionBase : FunctionMessage
    {
        [Parameter("address", "to", 1)]
        public virtual string To { 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 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", "value", 3)]
        public virtual BigInteger Value { 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 Price0CumulativeLastFunction : Price0CumulativeLastFunctionBase { }

    [Function("price0CumulativeLast", "uint256")]
    public class Price0CumulativeLastFunctionBase : FunctionMessage
    {

    }

    public partial class Price1CumulativeLastFunction : Price1CumulativeLastFunctionBase { }

    [Function("price1CumulativeLast", "uint256")]
    public class Price1CumulativeLastFunctionBase : FunctionMessage
    {

    }

    public partial class SkimFunction : SkimFunctionBase { }

    [Function("skim")]
    public class SkimFunctionBase : FunctionMessage
    {
        [Parameter("address", "to", 1)]
        public virtual string To { get; set; }
    }

    public partial class SwapFunction : SwapFunctionBase { }

    [Function("swap")]
    public class SwapFunctionBase : FunctionMessage
    {
        [Parameter("uint256", "amount0Out", 1)]
        public virtual BigInteger Amount0Out { get; set; }
        [Parameter("uint256", "amount1Out", 2)]
        public virtual BigInteger Amount1Out { get; set; }
        [Parameter("address", "to", 3)]
        public virtual string To { get; set; }
        [Parameter("bytes", "data", 4)]
        public virtual byte[] Data { get; set; }
    }

    public partial class SymbolFunction : SymbolFunctionBase { }

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

    }

    public partial class SyncFunction : SyncFunctionBase { }

    [Function("sync")]
    public class SyncFunctionBase : FunctionMessage
    {

    }

    public partial class Token0Function : Token0FunctionBase { }

    [Function("token0", "address")]
    public class Token0FunctionBase : FunctionMessage
    {

    }

    public partial class Token1Function : Token1FunctionBase { }

    [Function("token1", "address")]
    public class Token1FunctionBase : 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", "to", 1)]
        public virtual string To { get; set; }
        [Parameter("uint256", "value", 2)]
        public virtual BigInteger Value { get; set; }
    }

    public partial class TransferFromFunction : TransferFromFunctionBase { }

    [Function("transferFrom", "bool")]
    public class TransferFromFunctionBase : FunctionMessage
    {
        [Parameter("address", "from", 1)]
        public virtual string From { get; set; }
        [Parameter("address", "to", 2)]
        public virtual string To { get; set; }
        [Parameter("uint256", "value", 3)]
        public virtual BigInteger Value { 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", "value", 3, false )]
        public virtual BigInteger Value { get; set; }
    }

    public partial class BurnEventDTO : BurnEventDTOBase { }

    [Event("Burn")]
    public class BurnEventDTOBase : IEventDTO
    {
        [Parameter("address", "sender", 1, true )]
        public virtual string Sender { get; set; }
        [Parameter("uint256", "amount0", 2, false )]
        public virtual BigInteger Amount0 { get; set; }
        [Parameter("uint256", "amount1", 3, false )]
        public virtual BigInteger Amount1 { get; set; }
        [Parameter("address", "to", 4, true )]
        public virtual string To { get; set; }
    }

    public partial class MintEventDTO : MintEventDTOBase { }

    [Event("Mint")]
    public class MintEventDTOBase : IEventDTO
    {
        [Parameter("address", "sender", 1, true )]
        public virtual string Sender { get; set; }
        [Parameter("uint256", "amount0", 2, false )]
        public virtual BigInteger Amount0 { get; set; }
        [Parameter("uint256", "amount1", 3, false )]
        public virtual BigInteger Amount1 { get; set; }
    }

    public partial class SwapEventDTO : SwapEventDTOBase { }

    [Event("Swap")]
    public class SwapEventDTOBase : IEventDTO
    {
        [Parameter("address", "sender", 1, true )]
        public virtual string Sender { get; set; }
        [Parameter("uint256", "amount0In", 2, false )]
        public virtual BigInteger Amount0In { get; set; }
        [Parameter("uint256", "amount1In", 3, false )]
        public virtual BigInteger Amount1In { get; set; }
        [Parameter("uint256", "amount0Out", 4, false )]
        public virtual BigInteger Amount0Out { get; set; }
        [Parameter("uint256", "amount1Out", 5, false )]
        public virtual BigInteger Amount1Out { get; set; }
        [Parameter("address", "to", 6, true )]
        public virtual string To { get; set; }
    }

    public partial class SyncEventDTO : SyncEventDTOBase { }

    [Event("Sync")]
    public class SyncEventDTOBase : IEventDTO
    {
        [Parameter("uint112", "reserve0", 1, false )]
        public virtual BigInteger Reserve0 { get; set; }
        [Parameter("uint112", "reserve1", 2, false )]
        public virtual BigInteger Reserve1 { 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", "value", 3, false )]
        public virtual BigInteger Value { get; set; }
    }

    public partial class DOMAIN_SEPARATOROutputDTO : DOMAIN_SEPARATOROutputDTOBase { }

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

    public partial class MINIMUM_LIQUIDITYOutputDTO : MINIMUM_LIQUIDITYOutputDTOBase { }

    [FunctionOutput]
    public class MINIMUM_LIQUIDITYOutputDTOBase : 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 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 BurnOutputDTO : BurnOutputDTOBase { }

    [FunctionOutput]
    public class BurnOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint256", "amount0", 1)]
        public virtual BigInteger Amount0 { get; set; }
        [Parameter("uint256", "amount1", 2)]
        public virtual BigInteger Amount1 { get; set; }
    }

    public partial class DecimalsOutputDTO : DecimalsOutputDTOBase { }

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

    public partial class FactoryOutputDTO : FactoryOutputDTOBase { }

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

    public partial class GetReservesOutputDTO : GetReservesOutputDTOBase { }

    [FunctionOutput]
    public class GetReservesOutputDTOBase : IFunctionOutputDTO 
    {
        [Parameter("uint112", "_reserve0", 1)]
        public virtual BigInteger Reserve0 { get; set; }
        [Parameter("uint112", "_reserve1", 2)]
        public virtual BigInteger Reserve1 { get; set; }
        [Parameter("uint32", "_blockTimestampLast", 3)]
        public virtual uint BlockTimestampLast { get; set; }
    }



    public partial class KLastOutputDTO : KLastOutputDTOBase { }

    [FunctionOutput]
    public class KLastOutputDTOBase : 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 Price0CumulativeLastOutputDTO : Price0CumulativeLastOutputDTOBase { }

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

    public partial class Price1CumulativeLastOutputDTO : Price1CumulativeLastOutputDTOBase { }

    [FunctionOutput]
    public class Price1CumulativeLastOutputDTOBase : 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 Token0OutputDTO : Token0OutputDTOBase { }

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

    public partial class Token1OutputDTO : Token1OutputDTOBase { }

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

    public partial class TotalSupplyOutputDTO : TotalSupplyOutputDTOBase { }

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


}