/// <summary>
///
/// NOTE: UNDER CONSTRUCTION
///
/// This method will pull chrono logs from the ChronoLog contract.
///
/// <param name=""></param>
/// <returns></returns>
/// </summary>
public static async Task <List <string> > GetChronoLogs(this Wonka.Eth.Init.WonkaEthEngineInitialization poEngineInitData,
string psChronoLogContractAddr,
GetChronoLogEventsByTypeAndTimeFunction poGetChronoLogEventFunction)
{
List <string> ChronoLogs = new List <string>();
var account = new Nethereum.Web3.Accounts.Account(poEngineInitData.EthPassword);
Nethereum.Web3.Web3 SenderWeb3;
if (!String.IsNullOrEmpty(poEngineInitData.Web3HttpUrl))
{
SenderWeb3 = new Nethereum.Web3.Web3(account, poEngineInitData.Web3HttpUrl);
}
else
{
SenderWeb3 = new Nethereum.Web3.Web3(account);
}
var getLogsHandler = SenderWeb3.Eth.GetContractQueryHandler <GetChronoLogEventsByTypeAndTimeFunction>();
var ChronoLogList =
await getLogsHandler.QueryDeserializingToObjectAsync <GetChronoLogEventsByTypeAndTimeOutputDTOBase>(poGetChronoLogEventFunction, psChronoLogContractAddr);
ChronoLogList.ReturnValue1.ForEach(x => ChronoLogs.Add(Convert.ToString(x)));
return(ChronoLogs);
}
public async void ShouldDoFullValidation()
{
var owner = new Nethereum.Web3.Accounts.Account("0xb1939d6c8c73d6aa5ad97873c2f99a2dfc2b4c356acfd5338caff20392d7960d");
var signer = new Nethereum.Web3.Accounts.Account("0xa83369462189d7cc3d2aed78614d0df89f4d9651770fef9fc64b05acf7464a7f");
var guardian = new Nethereum.Web3.Accounts.Account("0xa0f2dd3adc8b79603f92736ac50843f1c5344514505b042369efdab105e9442b");
var immunityCertificate = new ImmunityCertificate();
immunityCertificate.OwnerAddress = owner.Address;
immunityCertificate.SignerAddress = signer.Address;
immunityCertificate.TestKitId = "TestKit1";
immunityCertificate.PhotoId = "QmbtqAxAnEqumx9k8wx8yxyANpC5vVwvQsdSWUQof9NP2o".DecodeBase58();
immunityCertificate.TestCentreId = "100";
immunityCertificate.Guardians = new System.Collections.Generic.List <string> {
guardian.Address
};
immunityCertificate.SetExpiryDate(DateTime.Now.AddDays(1000));
var signature = new EthereumMessageSigner().Sign(immunityCertificate.GetHashCertificate(), new EthECKey(signer.PrivateKey));
var signedCertificate = new SignedImmunityCertificate(immunityCertificate, signature);
var web3 = _ethereumClientIntegrationFixture.GetWeb3();
//admin deployer
var account = AccountFactory.GetAccount();
//simple deployment
//var web3 = new Nethereum.Web3.Web3(new Nethereum.Web3.Accounts.Account("0xb5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7"), "https://ropsten.infura.io/v3/7238211010344719ad14a89db874158c");
var tokenService = await Covid19CertificationService.DeployContractAndGetServiceAsync(web3, new Covid19CertificationDeployment());
var address = tokenService.ContractHandler.ContractAddress;
//Add Test Centre
var receiptAddTestCentre = await tokenService.UpsertTestCentreRequestAndWaitForReceiptAsync(new TestCentre()
{
TestCentreId = "100", Invalid = false
});
//Add Test Centre Owner
var receiptAddTestCentreOwner = await tokenService.UpsertTestCentreOwnerRequestAndWaitForReceiptAsync("100".ToUTF8Bytes(), account.Address, true);
//Add Test Centre Certificate Signer
var receiptAddTestCentreSigner = await tokenService.UpsertTestCentreCertSignerRequestAndWaitForReceiptAsync(new TestCentreCertSigner()
{
TestCentreId = "100", SignerAddress = signer.Address, Invalid = false, ExpiryDate = 0
});
var challenge = "testtest";
var challengeSigner = new EthereumMessageSigner();
var signatureOwner = challengeSigner.EncodeUTF8AndSign(challenge, new EthECKey(owner.PrivateKey));
var certificateText = signedCertificate.GenerateFullCertificate();
Assert.True(await tokenService.FullVerificationCertificateChallengeWithSignatureQueryAsync(signedCertificate, challenge, signatureOwner.HexToByteArray(), DateTimeOffset.Now.ToUnixTimeSeconds()));
var signatureGuardian = challengeSigner.EncodeUTF8AndSign(challenge, new EthECKey(guardian.PrivateKey));
Assert.True(await tokenService.FullVerificationCertificateChallengeWithSignatureQueryAsync(signedCertificate, challenge, signatureGuardian.HexToByteArray(), DateTimeOffset.Now.ToUnixTimeSeconds()));
}
public async Task <int> getInventory(Player player)
{
Console.WriteLine("started blockchain connection");
string playerAddress = player.address;
string contractAddress = "0xaafa19d6f354eee368e0bc6ed0a418cc8bf49763";
string abi = ABI.artifactsAbi;
// server account
var privateKey = "d1b10e2390ffd68062732bf5444494539abfabf4bd7442e753b7d4d7adb67256";
var account = new Nethereum.Web3.Accounts.Account(privateKey);
Web3 web3 = new Web3(account);
Contract contract = web3.Eth.GetContract(abi, contractAddress);
Console.WriteLine("got contract");
var getItemsAmount = contract.GetFunction("getArtifactsAmount");
var amount = await getItemsAmount.CallAsync <int>();
var getArtifactOwner = contract.GetFunction("artifactIndexToOwner");
var getArtifact = contract.GetFunction("getArtifactTypeId");
for (int i = 0; i < amount; ++i)
{
var artifactOwner = await getArtifactOwner.CallAsync <string>(i);
if (artifactOwner == playerAddress)
{
var typeId = await getArtifact.CallAsync <int>(i);
artifacts.Add(Artifact.CreateFromBlockchain(typeId, i));
}
}
Console.WriteLine("inventory loaded");
return(amount);
}
/// <summary>
/// Get the KMS Keyvalue
/// </summary>
/// <param name="keyName">Key Name</param>
/// <returns>Persisted Value</returns>
private async Task <string> GetKMSKeyValue(string keyName)
{
Web3 web3 = GetWeb3();
var account = new Nethereum.Web3.Accounts.Account(privateKey);
/** Function: getItem**/
var getItemRequest = new GetItemFunction
{
Key = keyName,
FromAddress = account.Address,
GasPrice = Web3.Convert.ToWei(25, UnitConversion.EthUnit.Gwei)
};
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls | SecurityProtocolType.Ssl3;
var keyQueryHandler = web3.Eth.GetContractQueryHandler <GetItemFunction>();
var getItemResponse = await keyQueryHandler
.QueryDeserializingToObjectAsync <GetItemOutputDTO>(
getItemRequest, txtKMSContractAddress.Text.Trim());
if (getItemResponse != null)
{
return(getItemResponse.ReturnValue1);
}
return(string.Empty);
}
private Web3 GetWeb3()
{
var account = new Nethereum.Web3.Accounts.Account(privateKey);
Web3 web3 = new Web3(account, contractDeploymentUrl);
return(web3);
}
private async void btnKMSSetItem_Click(object sender, EventArgs e)
{
if (ValidateKMSSet() == false)
{
return;
}
if (contractHandler == null &&
!string.IsNullOrEmpty(txtKMSContractAddress.Text.Trim()))
{
Web3 web3 = GetWeb3();
contractHandler = web3.Eth.GetContractHandler(txtKMSContractAddress.Text.Trim());
}
if (contractHandler == null)
{
MessageBox.Show("Problem in getting an instance of the Contract Handler. " +
"Please try specifying a valid Contract Address", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
StartProgressBar();
btnKMSSetItem.Enabled = false;
var encryptedText = RSAEncryptionHelper.Encrypt(txtValue.Text.Trim(), filteredCert);
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var setItemRequest = new SetItemFunction
{
Key = txtKeyName.Text.Trim(),
Value = encryptedText,
FromAddress = account.Address
};
// Set the Gas value
var estimate = await contractHandler
.EstimateGasAsync(setItemRequest);
setItemRequest.Gas = estimate.Value;
var setItemFunctionTxnReceipt = await contractHandler
.SendRequestAndWaitForReceiptAsync(setItemRequest);
if (setItemFunctionTxnReceipt != null &&
setItemFunctionTxnReceipt.BlockNumber.Value > 0)
{
string[] keyCollection = new string[3];
ListViewItem listItem;
keyCollection[0] = txtKeyName.Text.Trim();
keyCollection[1] = encryptedText;
keyCollection[2] = "";
listItem = new ListViewItem(keyCollection);
listView1.Items.Add(listItem);
}
btnKMSSetItem.Enabled = true;
StopProgressBar();
}
// NOTE: This code will need to be modified in order to work correctly
public static async Task <string> RegisterOnENS(this WonkaBizRulesEngine poEngine)
{
var durationInDays = 365; // how long we are going to rent the domain for
var ourName = "supersillynameformonkeys"; // Our xxxxx.eth domain name
var owner = "0x12890d2cce102216644c59dae5baed380d84830c"; // Owner of the domain
var secret = "animals in the forest"; //This is the commitment secret,
// it should be unique and remember it to be able to finalise your registration
var account = new Nethereum.Web3.Accounts.Account("YOURPRIVATE KEY");
var web3 = new Web3(account, "https://mainnet.infura.io/v3/7238211010344719ad14a89db874158c");
var ethTLSService = new EthTLSService(web3);
await ethTLSService.InitialiseAsync(); // Initialising to retrieve the controller
//How much is going to cost
var price = await ethTLSService.CalculateRentPriceInEtherAsync(ourName, durationInDays);
Console.WriteLine(price);
//Calculate the commitment that will be submitted for reservation
var commitment = await ethTLSService.CalculateCommitmentAsync(ourName, owner, secret);
Console.WriteLine(commitment.ToHex());
//You can now create your commitment and wait for it to be included on the chain
var commitTransactionReceipt = await ethTLSService.CommitRequestAndWaitForReceiptAsync(commitment);
// Once is on chain you can complete the registration
var txnHash = await ethTLSService.RegisterRequestAsync(ourName, owner, durationInDays, secret, price);
return(txnHash);
}
public async void ShouldInValidateChallengeNotValidCertificateSignature()
{
var incorrectowner = new Nethereum.Web3.Accounts.Account("0xb1939d6c8c73d6aa5ad97873c2f99a2dfc2b4c356acfd5338caff20392d7960d");
var signer = new Nethereum.Web3.Accounts.Account("0xa83369462189d7cc3d2aed78614d0df89f4d9651770fef9fc64b05acf7464a7f");
//var guardian = new Nethereum.Web3.Accounts.Account("0xa0f2dd3adc8b79603f92736ac50843f1c5344514505b042369efdab105e9442b");
var immunityCertificate = new ImmunityCertificate();
immunityCertificate.OwnerAddress = signer.Address; //owner is the signer so the ow
immunityCertificate.SignerAddress = signer.Address;
immunityCertificate.TestKitId = "TestKit1";
immunityCertificate.PhotoId = "QmbtqAxAnEqumx9k8wx8yxyANpC5vVwvQsdSWUQof9NP2o".DecodeBase58();
immunityCertificate.TestCentreId = "100";
// no guardians
// immunityCertificate.Guardians = new System.Collections.Generic.List<string> { guardian.Address };
immunityCertificate.SetExpiryDate(DateTime.Now.AddDays(1000));
var signature = new EthereumMessageSigner().Sign(immunityCertificate.GetHashCertificate(), new EthECKey(signer.PrivateKey));
var signedCertificate = new SignedImmunityCertificate(immunityCertificate, signature);
var web3 = _ethereumClientIntegrationFixture.GetWeb3();
var tokenService = await Covid19CertificationService.DeployContractAndGetServiceAsync(web3, new Covid19CertificationDeployment());
var challenge = "testtest";
var challengeSigner = new EthereumMessageSigner();
var signatureOwner = challengeSigner.EncodeUTF8AndSign(challenge, new EthECKey(incorrectowner.PrivateKey));
Assert.False(await tokenService.VerifyCertificateChallengeSignatureQueryAsync(signedCertificate, challenge, signatureOwner.HexToByteArray()));
}
static void Main(string[] args)
{
// The Digital Assistant, main account. When starting TestRPC, this address needs to be updated
var ecKey = new Nethereum.Signer.EthECKey("0xc6bd77dc9f1b685865155d05c5d5719f4e3c51bdac1d5f09172b2573773bbd04");
var privateKey = ecKey.GetPrivateKeyAsBytes();
var account = new Nethereum.Web3.Accounts.Account(privateKey);
// A new account for the agent
var agentKey = Nethereum.Signer.EthECKey.GenerateKey();
var agentAccount = new Nethereum.Web3.Accounts.Account(agentKey.GetPrivateKeyAsBytes());
Console.WriteLine($"Agent created: {agentAccount.Address}");
// Connect to the Ethereum network in the Digital Assistant account context, to create the contract
var web3 = new Nethereum.Web3.Web3(account);
var transactionHash = web3.Eth.DeployContract.SendRequestAsync(abi, byteCode, account.Address, new Nethereum.Hex.HexTypes.HexBigInteger(900000), agentAccount.Address).Result;
var receipt = MineAndGetReceipt(web3, transactionHash);
var contractAddress = receipt.ContractAddress;
Console.WriteLine($"Contract created: {contractAddress}");
Console.ReadKey();
var actor = ActorProxy.Create <IUserAgent>(ActorId.CreateRandom(), new Uri("fabric:/Transportation/UserAgentActorService"));
var retval = actor.GetTransportAsync("add schedule here", agentKey.GetPrivateKeyAsBytes(), contractAddress);
Console.WriteLine($"Result for getting transport data: {retval.Result}");
Console.ReadKey();
}
public static void Approve(string toAddress, int tokenId, string privateKey)
{
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var contract = SolidityMethods.Solidity.GetContract(privateKey);
var createCelestialObject = contract.GetFunction("approve");
var transactionHash =
createCelestialObject.SendTransactionAndWaitForReceiptAsync(account.Address, new HexBigInteger(900000), null, null, toAddress, tokenId).Result;
}
public static void SafeTransferFrom(string fromAddress, string toAddress, int tokenId, string privateKey)
{
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var contract = SolidityMethods.Solidity.GetContract(privateKey);
var safeTransferFrom = contract.GetFunction("safeTransferFrom");
var transactionHash =
safeTransferFrom.SendTransactionAndWaitForReceiptAsync(account.Address, new HexBigInteger(900000), null, null, fromAddress, toAddress, tokenId).Result;
}
private Web3 GetWeb3()
{
var privateKey = ConfigurationManager.GetString("privateKeyInsurance");
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var web3 = new Web3(account, ConfigurationManager.GetString("NetworkProvider"));
return(web3);
}
public EthereumWriter(AppConfig appConfig, RuntimeConfigHolder runtimeConfig, ILogger logFactory) : base(appConfig, logFactory)
{
_runtimeConfig = runtimeConfig;
_gmEthSender = new Nethereum.Web3.Accounts.Account(appConfig.Services.Ethereum.EthSenderPk);
// uses semaphore inside:
_gmEthSender.NonceService = new Nethereum.RPC.NonceServices.InMemoryNonceService(_gmEthSender.Address, EthProvider);
}
public static async Task MainProxy()
{
var url = "http://testchain.nethereum.com:8545";
//var url = "https://mainnet.infura.io";
var privateKey = "0x7580e7fb49df1c861f0050fae31c2224c6aba908e116b8da44ee8cd927b990b0";
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var web3 = new Web3(account, url);
var contractAddress = "0x.eee";
/* Deployment
* var adminUpgradeabilityProxyDeployment = new AdminUpgradeabilityProxyDeployment();
* adminUpgradeabilityProxyDeployment.Implementation = implementation;
* var transactionReceiptDeployment = await web3.Eth.GetContractDeploymentHandler<AdminUpgradeabilityProxyDeployment>().SendRequestAndWaitForReceiptAsync(adminUpgradeabilityProxyDeployment);
* var contractAddress = transactionReceiptDeployment.ContractAddress;
*/
var contractHandler = web3.Eth.GetContractHandler(contractAddress);
/** Function: upgradeTo**/
/*
* var upgradeToFunction = new UpgradeToFunction();
* upgradeToFunction.NewImplementation = newImplementation;
* var upgradeToFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(upgradeToFunction);
*/
/** Function: upgradeToAndCall**/
/*
* var upgradeToAndCallFunction = new UpgradeToAndCallFunction();
* upgradeToAndCallFunction.NewImplementation = newImplementation;
* upgradeToAndCallFunction.Data = data;
* var upgradeToAndCallFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(upgradeToAndCallFunction);
*/
/** Function: implementation**/
/*
* var implementationFunctionReturn = await contractHandler.QueryAsync<ImplementationFunction, string>();
*/
/** Function: changeAdmin**/
var changeAdminFunction = new ChangeAdminFunction();
changeAdminFunction.NewAdmin = "";
var changeAdminFunctionTxnReceipt = await contractHandler.SendRequestAndWaitForReceiptAsync(changeAdminFunction);
/** Function: admin**/
/*
* var adminFunctionReturn = await contractHandler.QueryAsync<AdminFunction, string>();
*/
}
private void button2_Click(object sender, EventArgs e)
{
var pk = textBox1.Text.Trim();
var account = new Nethereum.Web3.Accounts.Account(pk, EthereumServer.Chain);
var login = new LoggedInForm(account, EthereumServer);
login.Show();
Close();
}
public async Task <String> Post(String byteCode)
{
IAccount account = new Nethereum.Web3.Accounts.Account("0x3b3617c923fc5d7ea2aa1fc10d98e5b15cf1ade7b463c2dc929a1d2498137472", Nethereum.Signer.Chain.Rinkeby);
Web3 web3 = new Web3(account, "http://localhost:7545");
String tx = await web3.Eth.DeployContract.SendRequestAsync(byteCode, "0x627306090abaB3A6e1400e9345bC60c78a8BEf57");
return(tx);
}
public static Web3 GetWeb3(string privateKey)
{
var privKey = new Nethereum.Signer.EthECKey(privateKey);
var account = new Nethereum.Web3.Accounts.Account(privKey);
var web3 = new Web3(account, "https://ropsten.infura.io/v3/2105932667224bc4a18e97688178ad03");
return(web3);
}
public static string GetAddress(string privateKey, Web3 web3 = null)
{
string abi = Resources.DecentraverseABI;
string contractAddress = Resources.ContractAddress;
var privKey = new Nethereum.Signer.EthECKey(privateKey);
var account = new Nethereum.Web3.Accounts.Account(privKey);
return(account.Address);
}
public LoggedInForm(Nethereum.Web3.Accounts.Account account, EthereumServerClass ethereumServer)
{
InitializeComponent();
this.Icon = Icon.ExtractAssociatedIcon(Application.ExecutablePath);
EthereumServer = ethereumServer;
Account = account;
Web3 = new Nethereum.Web3.Web3(account, ethereumServer.Url);
InitializeData();
}
public async void Transaction()
{
string privateKey = "768737baf760264de8b8f9352ed135af8b7f69b9a6158ff616a00d81e03ab71a";
var account = new Nethereum.Web3.Accounts.Account(privateKey);
//var eth = new EthService(new Web3(account));
var result = await EthService.Instance.Transfer(privateKey, "0xFbF065C72Ad57611d26DCcd5041806fB5A988D92", "0xea7A01878d1886A7c55db3200144855A9547E905", 1000000000000000000, 300000, 99);
Console.WriteLine(result);
Assert.True(result != null);
}
public static string CardTokenIdToHash(int tokenId, string privateKey)
{
var contract = GetContract(privateKey);
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var celestialObjs = contract.GetFunction("CelestialObjects");
var res =
celestialObjs.CallAsync <string>(tokenId).Result;
return(res);
}
public static string CreateWallet(string password)
{
var web3 = new Web3();
var ecKey = Nethereum.Signer.EthECKey.GenerateKey();
var privateKey = ecKey.GetPrivateKeyAsBytes();
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var keystoreService = new Nethereum.KeyStore.KeyStoreService();
var keystore = keystoreService.EncryptAndGenerateDefaultKeyStoreAsJson(password, privateKey, account.Address);
return(keystore);
}
public static Contract GetContract(string privateKey, Web3 _web3 = null)
{
string abi = Resources.DecentraverseABI;
string contractAddress = Resources.ContractAddress;
var privKey = new Nethereum.Signer.EthECKey(privateKey);
var account = new Nethereum.Web3.Accounts.Account(privKey);
var web3 = _web3 ?? new Web3(account, "https://ropsten.infura.io/v3/2105932667224bc4a18e97688178ad03");
var contract = web3.Eth.GetContract(abi, contractAddress);
return(contract);
}
public static MyKey GetMyKeyFromPrivateKey(string privateKey)
{
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var key = new MyKey
{
PublicKey = account.Address,
PrivateKey = privateKey
};
return(key);
}
public async Task <string> MyCallingMethod()
{
//string password = "******";
//EthECKey key = EthECKey.GenerateKey();
//byte[] privateKey = key.GetPrivateKeyAsBytes();
//string address = key.GetPublicAddress();
//var keyStore = new KeyStoreScryptService();
//string json = keyStore.EncryptAndGenerateKeyStoreAsJson(
// password: password,
// privateKey: privateKey,
// addresss: address);
var ecKey = Nethereum.Signer.EthECKey.GenerateKey();
var privateKeyr = ecKey.GetPrivateKeyAsBytes().ToHex();
var accountr = new Nethereum.Web3.Accounts.Account(privateKeyr);
var web3 = new Nethereum.Web3.Web3("http://localhost:8545/");
var newacont = web3.Eth.Accounts.SendRequestAsync(privateKeyr);
var newacontr = await web3.Eth.Transactions.GetTransactionReceipt.SendRequestAsync(privateKeyr);
//var balance = web3.Eth.GetBalance.SendRequestAsync("0xee18c75a5f2c3896EcA1026751C80e9C6B96c878");
///var balance = web3.Eth.GetBalance.SendRequestAsync("0x6f7d8d0378993fe55628257710160f3bb83490b0");
//var txCount = web3.Eth.Transactions.GetTransactionCount.SendRequestAsync("0x4D7fB0C555314222e0690fe80DAE8Ba2F9450595");
////var privateKey = "0x7580e7fb49df1c861f0050fae31c2224c6aba908e116b8da44ee8cd927b990b0";
////var account = new Account(privateKey);
////Console.WriteLine("Our account: " + account.Address);
//////Now let's create an instance of Web3 using our account pointing to our nethereum testchain
//var web3 = new Web3(accountr, "http://testchain.nethereum.com:8545");
//// //Check the balance of the account we are going to send the Ether
// var balance = web3.Eth.GetBalance.SendRequestAsync("0xB0E8Cb105Ab63300b96aA230c9528f49dd087333");
//// //Console.WriteLine("Receiver account balance before sending Ether: " + balance.Value + " Wei");
// //Console.WriteLine("Receiver account balance before sending Ether: " + Web3.Convert.FromWei(balance.Value) + " Ether");
////// Lets transfer 1.11 Ether
// var transaction = web3.Eth.GetEtherTransferService().TransferEtherAndWaitForReceiptAsync(accountr.ToString(), 1.11m);
////balance = await web3.Eth.GetBalance.SendRequestAsync("0x13f022d72158410433cbd66f5dd8bf6d2d129924");
////Console.WriteLine("Receiver account balance after sending Ether: " + balance.Value);
////Console.WriteLine("Receiver account balance after sending Ether: " + Web3.Convert.FromWei(balance.Value) +
//// " Ether");
///
return(newacont.ToString());
}
public static IEnumerable <int> GetCardTokenIds(string privateKey)
{
List <int> listToReturn = new List <int>();
var contract = GetContract(privateKey);
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var transferEvent = contract.GetEvent("Transfer");
var filterAll = transferEvent.CreateFilterInput(new BlockParameter(4267026), null);
var instances = transferEvent.GetAllChanges <TransferEvent>(filterAll);
listToReturn = instances.Result.Where(ee => ee.Event.To.ToLower() == account.Address.ToLower()).Select(e => e.Event.TokenId)
.ToList();
return(listToReturn);
}
public static MyKey Generate()
{
var ecKey = Nethereum.Signer.EthECKey.GenerateKey();
var privateKey = ecKey.GetPrivateKeyAsBytes().ToHex();
var account = new Nethereum.Web3.Accounts.Account(privateKey);
var myKey = new MyKey
{
PublicKey = account.Address,
PrivateKey = privateKey
};
return(myKey);
}
public WonkaEthERC721OpSource(string psSourceId, string psSenderAddr, string psPwd, string psContractAddr, string psCustomOpMethodName, string psWeb3Url = "") :
base(psSourceId, psSenderAddr, psPwd, psContractAddr, null, null, psCustomOpMethodName)
{
var account = new Nethereum.Web3.Accounts.Account(psPwd);
if (!String.IsNullOrEmpty(psWeb3Url))
{
SenderWeb3 = new Nethereum.Web3.Web3(account, psWeb3Url);
}
else
{
SenderWeb3 = new Nethereum.Web3.Web3(account);
}
}
public static Web3 GetWeb3(string psPassword, string psWeb3HttpUrl)
{
var account = new Nethereum.Web3.Accounts.Account(psPassword);
Web3 web3 = null;
if (!String.IsNullOrEmpty(psWeb3HttpUrl))
{
web3 = new Web3(account, psWeb3HttpUrl);
}
else
{
web3 = new Web3(account);
}
return(web3);
}
public static String CreateNewEthereumAddressAsync()
{
var ecKey = Nethereum.Signer.EthECKey.GenerateKey();
var privateKey = ecKey.GetPrivateKeyAsBytes().ToHex();
var account = new Nethereum.Web3.Accounts.Account(privateKey);
//don't judge, I'm sure there are 9999 better ways to do it, but googleing would take more time than writing it.
String returnJson = "{\"privateKey\":\"";
returnJson += privateKey;
returnJson += "\",";
returnJson += "\"publicKey\":\"";
returnJson += account.Address;
returnJson += '"';
returnJson += '}';
return(returnJson);
}
