Skip to content

Instantly share code, notes, and snippets.

@juanfranblanco
Last active January 21, 2021 16:52
Show Gist options
  • Save juanfranblanco/844d15dfed84987346dc095f900cc9e5 to your computer and use it in GitHub Desktop.
Save juanfranblanco/844d15dfed84987346dc095f900cc9e5 to your computer and use it in GitHub Desktop.
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; }
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment