Skip to content

Instantly share code, notes, and snippets.

@juanfranblanco

juanfranblanco/Keep3r.cs

Created January 31, 2021 09:24
Show Gist options
  • Save juanfranblanco/e824ab6f0004b9a0c43d0c7717571a9e to your computer and use it in GitHub Desktop.
Save juanfranblanco/e824ab6f0004b9a0c43d0c7717571a9e to your computer and use it in GitHub Desktop.
Download ZIP
Raw
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; }
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment