internal ETHTaskTransferResponse ETH_Sign(int[] SecretSalt, int[] SecretPW, BitfiWallet.NOXWS.NoxTxnProcess tproc)
{
ETHTaskTransferResponse taskTransferResponse = new ETHTaskTransferResponse();
byte[] keybytes = HDDerriveKey(SecretSalt, SecretPW, 0, "eth");
EthECKey key = new EthECKey(keybytes, true);
Sclear.EraseBytes(keybytes);
string ethadr = key.GetPublicAddress();
if (ethadr != tproc.NoxAddress.BTCAddress)
{
taskTransferResponse.Error = "Invalid information.";
return(taskTransferResponse);
}
//TO DO
if (tproc.ETCToken != null)
{
var contractAddress = tproc.ETCToken.EnsureHexPrefix();
var to = tproc.ToAddress.EnsureHexPrefix();
var amount = NumUtils.Utils.ParseMoney(tproc.Amount, 18);
var nonce = System.Numerics.BigInteger.Parse(tproc.ETCNonce);
var gasPrice = NumUtils.Utils.ParseMoney(tproc.FeeValue, 18);
var gasLimit = new System.Numerics.BigInteger(Int64.Parse(tproc.ETCGasUsed));
var tx = new EthereumLibrary.Signer.Transaction(contractAddress, to, amount, nonce, gasPrice, gasLimit);
tx.Sign(key);
var signedHex = tx.ToHex();
key = null;
taskTransferResponse.TxnHex = signedHex;
return(taskTransferResponse);
}
else
{
var to = tproc.ToAddress.EnsureHexPrefix();
var amount = NumUtils.Utils.ParseMoney(tproc.Amount, 18);
var nonce = System.Numerics.BigInteger.Parse(tproc.ETCNonce);
var gasPrice = NumUtils.Utils.ParseMoney(tproc.FeeValue, 18);
var gasLimit = new System.Numerics.BigInteger(Int64.Parse(tproc.ETCGasUsed));
var tx = new EthereumLibrary.Signer.Transaction(to, amount, nonce, gasPrice, gasLimit);
tx.Sign(key);
var signedHex = tx.ToHex();
key = null;
taskTransferResponse.TxnHex = signedHex;
return(taskTransferResponse);
}
}
public void InstantiateWalletAndSaveOnDisk(String wordsChain, String password)
{
m_wallet = new Wallet(wordsChain, null);
SetCurrentAddress(EthECKey.GetPublicAddress(ProviderManager.instance.m_wallet.GetWalletPrivateKeyAsString()));
KeyStoreService m_keystoreService = new KeyStoreService();
Debug.Log(Application.persistentDataPath);
string keystoreJSON = m_keystoreService.EncryptAndGenerateDefaultKeyStoreAsJson(password, ProviderManager.instance.m_wallet.GetWalletPrivateKeyAsByte(), accountAddress);
SaveJSONOnDisk(keystoreJSON, Application.persistentDataPath + "/keystore.ks");
}
/// <summary>
/// Sends a message to an ethereum smart contract with the intent to change a part of the contract on the blockchain.
/// </summary>
/// <typeparam name="TFunc"> The <see cref="FunctionMessage"/> to execute on the blockchain given the contract address. </typeparam>
/// <param name="function"> The function to execute. </param>
/// <param name="contractAddress"> The contract address to execute the <see cref="FunctionMessage"/> on. </param>
/// <param name="privateKey"> The private key of the address sending the transaction. </param>
/// <param name="gasPrice"> The <see cref="BigInteger"/> gas price to use with the transaction. </param>
/// <returns> Promise of the transaction result of sending the contract message. </returns>
public static EthTransactionPromise SendContractMessage <TFunc>(
TFunc function,
string contractAddress,
string privateKey,
BigInteger gasPrice) where TFunc : FunctionMessage
{
EthECKey ethKey = new EthECKey(privateKey);
var promise = new EthTransactionPromise();
GasUtils.EstimateContractGasLimit(function, contractAddress, ethKey.GetPublicAddress())
.OnSuccess(gasLimit => _SendContractMessageCoroutine(function, promise, contractAddress, privateKey, gasPrice, gasLimit).StartCoroutine());
return(promise);
}
/// <summary>
/// Decrypt and setup wallet from Keystore
/// </summary>
/// <param name="PK">Password</param>
/// <returns>The Wallet</returns>
public WalletData importFromKeyStore(string keyStore, string password)
{
var service = new Nethereum.KeyStore.KeyStoreService();
var key = new Nethereum.Signer.EthECKey(
service.DecryptKeyStoreFromJson(password, keyStore),
true);
var address = EthECKey.GetPublicAddress(key.GetPrivateKey());
_wallet = new WalletData {
address = address, PK = key.GetPrivateKey()
};
_web3 = new Web3(new Nethereum.Web3.Accounts.Account(_wallet.PK), NodeUrl);
return(_wallet);
}
private string GetFirstETH(ExtKey masterKey)
{
ExtKey masterKeyA = masterKey.Derive(GetCurrencyIndex("eth"), hardened: true);
ExtKey key = masterKeyA.Derive((uint)0);
byte[] keybytes = key.PrivateKey.ToBytes();
EthECKey ETHkey = new EthECKey(keybytes, true);
string ethadr = ETHkey.GetPublicAddress();
Sclear.EraseBytes(keybytes);
masterKeyA = null;
key = null;
ETHkey = null;
return(ethadr);
}
public void importAccountFromPrivateKey()
{
// Here we try to get the public address from the secretKey we defined
try
{
var address = EthECKey.GetPublicAddress(accountPrivateKey);
// Then we define the accountAdress private variable with the public key
accountAddress = address;
}
catch (Exception e)
{
// If we catch some error when getting the public address, we just display the exception in the console
Debug.Log("Error importing account from PrivateKey: " + e);
}
}
public WalletInfo(string keyStoreJson, string password)
{
if (keyStoreJson == null)
{
throw new ArgumentNullException(nameof(keyStoreJson));
}
if (password == null)
{
throw new ArgumentNullException(nameof(password));
}
PrivateKey = HexHelper.ToHex(new KeyStoreService()
.DecryptKeyStoreFromJson(password, keyStoreJson), true);
Address = EthECKey.GetPublicAddress(PrivateKey);
}
private void LoadWalletFromKeystore(string keystoreJson, string password)
{
if (string.IsNullOrEmpty(keystoreJson) || string.IsNullOrEmpty(password))
{
throw new System.InvalidOperationException("keystoreJson or password is null or empty");
}
var keystoreservice = new Nethereum.KeyStore.KeyStoreService();
var privateKey = keystoreservice.DecryptKeyStoreFromJson(password, keystoreJson);
var ecKey = new EthECKey(privateKey, true);
var address = ecKey.GetPublicAddress();
PrivateKeyBytes = privateKey;
PrivateKeyString = privateKey.ToHex();
PublicAddress = address;
}
public void ShouldSignEncodeTransactionAndRecoverPublicAddress()
{
var privateKey = "b5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7";
var sendersAddress = "12890d2cce102216644c59daE5baed380d84830c";
var publicKey =
"87977ddf1e8e4c3f0a4619601fc08ac5c1dcf78ee64e826a63818394754cef52457a10a599cb88afb7c5a6473b7534b8b150d38d48a11c9b515dd01434cceb08";
var key = new EthECKey(privateKey.HexToByteArray(), true);
var hash = "test".ToHexUTF8().HexToByteArray();
var signature = key.Sign(hash);
Assert.True(key.Verify(hash, signature));
Assert.Equal(key.GetPubKeyNoPrefix().ToHex(), publicKey);
Assert.Equal(sendersAddress.EnsureHexPrefix().ToLower(), key.GetPublicAddress().EnsureHexPrefix().ToLower());
}
public static async Task <string> GetEthereumBalance(User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
var contractFunctions = Globals.GetInstance().ContractFunctions;
string res;
try
{
res = await contractFunctions.GetUserBalance(user.PublicKey, user.PrivateKey);
}
catch (Exception e)
{
return(e.Message);
}
return(res);
}
public static async Task <string> GetTokenBalance(User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
ulong res;
var contractFunctions = Globals.GetInstance().ContractFunctions;
try
{
res = await contractFunctions.CallFunctionByName <UInt64>(user.PublicKey, user.PrivateKey, FunctionNames.Balance, user.PublicKey);
}
catch (Exception e)
{
return(e.Message);
}
return(res.ToString());
}
public static string Create(UInt64 id, CreatePaymentPattern req, User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
TransactionReceipt result;
try
{
result = TokenFunctionsResults <int> .InvokeByTransaction(user, FunctionNames.CreatePayment, req.Gas, new object[] { id, req.Value });
}
catch (Exception e)
{
return(JsonConvert.SerializeObject(e.Message));
}
return(JsonConvert.SerializeObject(result));
}
public static string DepositToContract(DepositPattern req, User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
TransactionReceipt result;
try
{
result = TokenFunctionsResults <UInt64> .InvokeByTransaction(user, FunctionNames.Deposit, Value : req.Value, Gas : req.Gas);
}
catch (Exception e)
{
return(JsonConvert.SerializeObject(e.Message));
}
return(JsonConvert.SerializeObject(result));
}
public static string DisApprove(UInt64 id, DefaultControllerPattern req, User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
TransactionReceipt result;
try
{
result = TokenFunctionsResults <int> .InvokeByTransaction(user, FunctionNames.DisApproveRefund, req.Gas, funcParametrs : id);
}
catch (Exception e)
{
return(JsonConvert.SerializeObject(e.Message));
}
return(JsonConvert.SerializeObject(result));
}
public void ShouldCreateASignedTransaction()
{
var privateKey = "b5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7";
var sendersAddress = "12890d2cce102216644c59daE5baed380d84830c";
var publicKey =
"87977ddf1e8e4c3f0a4619601fc08ac5c1dcf78ee64e826a63818394754cef52457a10a599cb88afb7c5a6473b7534b8b150d38d48a11c9b515dd01434cceb08";
//data use for other tools for comparison
Debug.WriteLine(new HexBigInteger(10000).HexValue);
Debug.WriteLine(new HexBigInteger(324).HexValue);
Debug.WriteLine(new HexBigInteger(10000000000000).HexValue);
Debug.WriteLine(new HexBigInteger(21000).HexValue);
//Create a transaction from scratch
var tx = new Transaction("0x13f022d72158410433cbd66f5dd8bf6d2d129924", 10000, 324, 10000000000000, 21000);
tx.Sign(new ECKey(privateKey.HexToByteArray(), true));
var encoded = tx.GetRLPEncoded();
var rlp =
"f8698201448609184e72a0008252089413f022d72158410433cbd66f5dd8bf6d2d129924822710801ca0b1874eb8dab80e9072e57b746f8f0f281890568fd655488b0a1f5556a117775ea06ea87e03a9131cae14b5420cbfeb984bb2641d76fb32327d87cf0c9c0ee8f234";
Assert.Equal(rlp, encoded.ToHex());
//data used for other tools for comparison
Debug.WriteLine(encoded.ToHex());
Assert.Equal(EthECKey.GetPublicAddress(privateKey), tx.Key.GetPublicAddress());
var tx3 = new Transaction(rlp.HexToByteArray());
Assert.Equal(tx.Data, tx3.Data);
Debug.WriteLine(tx.ToJsonHex());
var tx2 = new Transaction(tx.GetRLPEncoded());
Assert.Equal(EthECKey.GetPublicAddress(privateKey), tx2.Key.GetPublicAddress());
Assert.Equal(tx.GasLimit.ToHex(), tx3.GasLimit.ToHex());
Assert.Equal(tx.Nonce.ToHex(), tx3.Nonce.ToHex());
Assert.Equal(tx.GasPrice.ToHex(), tx3.GasPrice.ToHex());
Assert.Equal(tx.Value.ToHex(), tx3.Value.ToHex());
Assert.Equal(tx.RawHash.ToHex(), tx3.RawHash.ToHex());
Assert.Equal(tx3.Key.GetPublicAddress(), tx.Key.GetPublicAddress());
Assert.Equal(tx2.RawHash.ToHex(), tx3.RawHash.ToHex());
Assert.Equal(tx2.Key.GetPublicAddress(), tx.Key.GetPublicAddress());
}
public void LoadAccount()
{
var encryptedJson = PlayerPrefs.GetString("encryptedJson");
Debug.Log("encryptedJson " + encryptedJson);
var password = "******";
var keystoreservice = new Nethereum.KeyStore.KeyStoreService();
var privateKey = keystoreservice.DecryptKeyStoreFromJson(password, encryptedJson);
var ecKey = new EthECKey(privateKey, true);
var address = ecKey.GetPublicAddress();
Debug.Log("address: " + address + "\n privateKey: " + privateKey.ToString());
accountAddress = address;
accountPrivateKey = privateKey.ToHex();
Debug.Log("accountAddress: " + accountAddress + "\n accountPrivateKey: " + accountPrivateKey);
}
/// <summary>
/// Decrypt and setup wallet from Keystore
/// </summary>
/// <param name="keyStore">Encrypted Keystore</param>
/// <param name="password">Password used on encryption</param>
/// <returns>The Wallet</returns>
public WalletData importFromKeyStore(string keyStore, string password)
{
var service = new Nethereum.KeyStore.KeyStoreService();
var key = new Nethereum.Signer.EthECKey(
service.DecryptKeyStoreFromJson(password, keyStore),
true);
var address = EthECKey.GetPublicAddress(key.GetPrivateKey());
_wallet = new WalletData {
address = address, PK = key.GetPrivateKey()
};
_web3 = new Web3(new Nethereum.Web3.Accounts.Account(_wallet.PK, _chainId), _nodeUrl);
_paymentChannelsContract = _web3.Eth.GetContract(PaymentChannelsABI, _paymentChannelsContractAddress);
_validatorsContract = _web3.Eth.GetContract(ValidatorsABI, _validatorsContractAddress);
return(_wallet);
}
public void TestTransactionFromUnSignedRLP()
{
var tx = new Transaction(RLP_ENCODED_UNSIGNED_TX.HexToByteArray());
Assert.Equal(RLP_ENCODED_UNSIGNED_TX, tx.GetRLPEncoded().ToHex());
Assert.Equal(BigInteger.Zero, tx.Nonce.ToBigIntegerFromRLPDecoded());
Assert.Equal(testGasPrice.ToBigIntegerFromRLPDecoded(), tx.GasPrice.ToBigIntegerFromRLPDecoded());
Assert.Equal(testGasLimit.ToBigIntegerFromRLPDecoded(), tx.GasLimit.ToBigIntegerFromRLPDecoded());
Assert.Equal(testReceiveAddress.ToHex(), tx.ReceiveAddress.ToHex());
Assert.Equal(testValue.ToBigIntegerFromRLPDecoded(), tx.Value.ToBigIntegerFromRLPDecoded());
Assert.Equal(HASH_TX, tx.RawHash.ToHex());
tx.Sign(new EthECKey(KEY.HexToByteArray(), true));
tx.Key.Verify(tx.RawHash, tx.Signature);
Assert.Equal(EthECKey.GetPublicAddress(KEY), tx.Key.GetPublicAddress());
}
public static async Task <string> GetCommision(ComissionControllerPattern req, User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
ContractFunctions contractFunctions = Globals.GetInstance().ContractFunctions;
TransactionReceipt res;
try
{
res = await contractFunctions.CallFunctionByNameSendTransaction(user.PublicKey, user.PrivateKey, FunctionNames.SetComission, req.Gas, parametrsOfFunction : req.Comission);
}
catch (Exception e)
{
return(JsonConvert.SerializeObject(e.Message));
}
return(JsonConvert.SerializeObject(res));
}
private string GetPrivateKeyFromKeystore(string pass)
{
if (keystoreJSON == null || keystoreJSON == "" || pass == null || pass == "")
{
return("");
}
byte[] b = m_keystoreService.DecryptKeyStoreFromJson(pass, keystoreJSON);
EthECKey myKey = new EthECKey(b, true);
if (myKey.GetPublicAddress() != accountAddress)
{
return("");
}
return(myKey.GetPrivateKey());
}
private static void Main(string[] args)
{
string input = File.ReadAllText("../../../Input.json");
EthereumSignature inputSignature = JsonConvert.DeserializeObject <EthereumSignature>(input);
byte[] messageBytes = Utils.GetBytes(inputSignature.Message);
byte[] messageHash = new Sha3Keccack().CalculateHash(messageBytes);
int recId = inputSignature.V.HexToByteArray()[0];
EthECDSASignature signature = EthECDSASignatureFactory.FromComponents(
inputSignature.R.HexToByteArray(),
inputSignature.S.HexToByteArray());
EthECKey publicKey = EthECKey.RecoverFromSignature(signature, recId, messageHash);
Console.WriteLine("Public address: {0}", publicKey.GetPublicAddress());
}
public TransactionSignedUnityRequest(string url, string privateKey, BigInteger?chainId = null, Dictionary <string, string> requestHeaders = null)
{
_chainId = chainId;
_url = url;
_account = EthECKey.GetPublicAddress(privateKey);
_privateKey = privateKey;
_transactionSigner = new LegacyTransactionSigner();
_ethSendTransactionRequest = new EthSendRawTransactionUnityRequest(_url);
_ethSendTransactionRequest.RequestHeaders = requestHeaders;
_transactionCountRequest = new EthGetTransactionCountUnityRequest(_url);
_transactionCountRequest.RequestHeaders = requestHeaders;
_ethEstimateGasUnityRequest = new EthEstimateGasUnityRequest(_url);
_ethEstimateGasUnityRequest.RequestHeaders = requestHeaders;
_ethGasPriceUnityRequest = new EthGasPriceUnityRequest(_url);
_ethGasPriceUnityRequest.RequestHeaders = requestHeaders;
Fee1559SuggestionStrategy = new SimpleFeeSuggestionUnityRequestStrategy(url, requestHeaders);
}
public static async Task <string> GetById(UInt64 id, User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
ContractFunctions contractFunctions = Globals.GetInstance().ContractFunctions;
TokenAPI.Payment res;
try
{
res = await contractFunctions.DeserializePaymentById(user.PublicKey, user.PrivateKey, id);
}
catch (Exception e)
{
return(JsonConvert.SerializeObject(e.Message));
}
return(JsonConvert.SerializeObject(res));
}
public static async Task <string> DeployContract(DefaultControllerPattern req, User user)
{
user.PublicKey = EthECKey.GetPublicAddress(user.PrivateKey);
TransactionReceipt contractReceipt;
ContractFunctions contractFunctions;
try
{
contractFunctions = Globals.GetInstance().ContractFunctions;
contractReceipt = await contractFunctions.DeployContract(user.PublicKey, user.PrivateKey, req.Gas);
}
catch (Exception e)
{
return(JsonConvert.SerializeObject(e.Message));
}
return(JsonConvert.SerializeObject(contractReceipt));
}
public void RetrieveWallet()
{
//Loader.instance.StartLoad();
string wordsChain = Words[0].text + " " + Words[1].text + " " + Words[2].text + " " + Words[3].text + " " + Words[4].text + " " + Words[5].text + " " + Words[6].text + " " + Words[7].text + " " + Words[8].text + " " + Words[9].text + " " + Words[10].text + " " + Words[11].text;
m_wallet = new Wallet(wordsChain, null);
accountAddress = EthECKey.GetPublicAddress(m_wallet.GetWalletPrivateKeyAsString());
keystoreJSON = m_keystoreService.EncryptAndGenerateDefaultKeyStoreAsJson(Password.text, m_wallet.GetWalletPrivateKeyAsByte(), accountAddress);
SaveJSONOnDisk();
Canvas.SetActive(false);
//LobbyManager.instance.Activate("Account", CreateBlocky());
//Loader.instance.StopLoad();
}
public void ConfigureServices(IServiceCollection services)
{
services.AddSingleton <IMaintenanceService>(sp =>
{
var key = Configuration["PrivateKey"];
var privateKey = new EthECKey(key);
var address = privateKey.GetPublicAddress();
var account = new Account(privateKey);
var web3 = new Web3(account, Configuration["GatewayUrl"]);
return(new EthereumMaintenanceService(web3,
privateKey,
Configuration["SmartContractAddress"],
Configuration["Abi"]));
});
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}
public void ShouldCreateASignedTransaction()
{
var privateKey = "b5b1870957d373ef0eeffecc6e4812c0fd08f554b37b233526acc331bf1544f7";
//data use for other tools for comparison
Debug.WriteLine(new HexBigInteger(10000).HexValue);
Debug.WriteLine(new HexBigInteger(324).HexValue);
Debug.WriteLine(new HexBigInteger(10000000000000).HexValue);
Debug.WriteLine(new HexBigInteger(21000).HexValue);
//Create a transaction from scratch
var tx = new Transaction("0x13f022d72158410433cbd66f5dd8bf6d2d129924", 10000, 324, 10000000000000, 21000);
tx.Sign(new EthECKey(privateKey.HexToByteArray(), true));
var encoded = tx.GetRLPEncoded();
var rlp =
"f8698201448609184e72a0008252089413f022d72158410433cbd66f5dd8bf6d2d129924822710801ca0b1874eb8dab80e9072e57b746f8f0f281890568fd655488b0a1f5556a117775ea06ea87e03a9131cae14b5420cbfeb984bb2641d76fb32327d87cf0c9c0ee8f234";
Assert.Equal(rlp, encoded.ToHex());
//data used for other tools for comparison
Debug.WriteLine(encoded.ToHex());
Assert.Equal(EthECKey.GetPublicAddress(privateKey), tx.Key.GetPublicAddress());
var tx3 = new Transaction(rlp.HexToByteArray());
Assert.Equal(tx.Data, tx3.Data ?? new byte[] { });
Debug.WriteLine(tx.ToJsonHex());
var tx2 = new Transaction(tx.GetRLPEncoded());
Assert.Equal(EthECKey.GetPublicAddress(privateKey), tx2.Key.GetPublicAddress());
Assert.Equal(tx.GasLimit.ToHex(), tx3.GasLimit.ToHex());
Assert.Equal(tx.Nonce.ToHex(), tx3.Nonce.ToHex());
Assert.Equal(tx.GasPrice.ToHex(), tx3.GasPrice.ToHex());
Assert.Equal(tx.Value.ToHex(), tx3.Value.ToHex());
Assert.Equal(tx.RawHash.ToHex(), tx3.RawHash.ToHex());
Assert.Equal(tx3.Key.GetPublicAddress(), tx.Key.GetPublicAddress());
Assert.Equal(tx2.RawHash.ToHex(), tx3.RawHash.ToHex());
Assert.Equal(tx2.Key.GetPublicAddress(), tx.Key.GetPublicAddress());
}
public ExecTransactionFunction BuildTransaction(
EncodeTransactionDataFunction transactionData,
BigInteger chainId,
params string[] privateKeySigners)
{
var signer = new Eip712TypedDataSigner();
var messageSigner = new MessageSigner();
var domain = new Domain
{
VerifyingContract = this.ContractHandler.ContractAddress,
ChainId = chainId
};
var encodedMessage = signer.EncodeTypedData(transactionData, domain, "SafeTx");
var hashEncoded = Util.Sha3Keccack.Current.CalculateHash(encodedMessage);
var signatures = new List <SafeSignature>();
foreach (var privateKey in privateKeySigners)
{
var publicAddress = EthECKey.GetPublicAddress(privateKey);
var signature = messageSigner.Sign(hashEncoded, privateKey);
signatures.Add(new SafeSignature()
{
Address = publicAddress, Signature = signature
});
}
var fullSignature = GetCombinedSignaturesInOrder(signatures);
return(new ExecTransactionFunction()
{
To = transactionData.To,
Value = transactionData.Value,
Data = transactionData.Data,
Operation = transactionData.Operation,
SafeTxGas = transactionData.SafeTxGas,
BaseGas = transactionData.BaseGas,
SafeGasPrice = transactionData.SafeGasPrice,
GasToken = transactionData.GasToken,
RefundReceiver = transactionData.RefundReceiver,
Signatures = fullSignature
});
}
///////////////////////////////////////////////////////////////////////////////////////
public static async Task <string> SendToken(string PrivateKeyFrom, string PublicKeyTo, float value)
{
//get the function
var function = meaToken.Contract.GetFunction("transfer");
//get the data
var data = function.GetData(new object[] { PublicKeyTo, new BigInteger(value) });
// var estimatedGaz = await function.EstimateGasAsync(new object[] { PublicKeyTo, new BigInteger(value) });
//Console.WriteLine("Estimated Gaz : " + estimatedGaz);
//nonce
var txCount = await web3.Eth.Transactions.GetTransactionCount.SendRequestAsync(EthECKey.GetPublicAddress(PrivateKeyFrom), BlockParameter.CreatePending());
//signing the transaction
var encoded = transactionSigner.SignTransaction(PrivateKeyFrom, meaToken.Contract.Address, 1, txCount.Value, 1000000000000L, 900000, data);
//estimate gaz
var GasEstimated = await web3.Eth.TransactionManager.EstimateGasAsync(new CallInput("0x" + encoded, PublicKeyTo));
Console.WriteLine("Estimated Gas is : " + GasEstimated.Value.ToString());
Console.WriteLine("My balance : " + web3.Eth.GetBalance.SendRequestAsync(EthECKey.GetPublicAddress(PrivateKeyFrom)).Result.Value.ToString());
//transaction hash
var bal = await get_MeaToken_Account_Balance(EthECKey.GetPublicAddress(PrivateKeyFrom));
Console.WriteLine("bal : " + bal);
var txId = await web3.Eth.Transactions.SendRawTransaction.SendRequestAsync("0x" + encoded);
//verify transaction
var status = transactionSigner.VerifyTransaction(encoded);
Console.WriteLine("Status : " + status);
//returning transaction hash
isMined(txId);
return(txId);
}
/// <summary>
/// Coroutine which sends a message to an ethereum smart contract.
/// </summary>
/// <typeparam name="TFunc"> The <see cref="FunctionMessage"/> to execute on the blockchain given the contract address. </typeparam>
/// <param name="function"> The function to execute. </param>
/// <param name="promise"> Promise of the transaction result of sending the contract message. </param>
/// <param name="contractAddress"> The contract address to execute the <see cref="FunctionMessage"/> on. </param>
/// <param name="privateKey"> The private key of the address sending the transaction. </param>
/// <param name="gasPrice"> The <see cref="BigInteger"/> gas price to use with the transaction. </param>
/// <param name="gasLimit"> The <see cref="BigInteger"/> gas limit to use with the transaction. </param>
private static IEnumerator _SendContractMessageCoroutine <TFunc>(
TFunc function,
EthTransactionPromise promise,
string contractAddress,
string privateKey,
BigInteger gasPrice,
BigInteger gasLimit) where TFunc : FunctionMessage
{
EthECKey ethKey = new EthECKey(privateKey);
function.SetDefaultFromAddressIfNotSet(ethKey.GetPublicAddress());
function.Gas = gasLimit;
function.GasPrice = gasPrice;
TransactionSignedUnityRequest unityRequest = new TransactionSignedUnityRequest(NetworkProvider.GetNetworkChainUrl(), privateKey, ethKey.GetPublicAddress());
yield return(unityRequest.SignAndSendTransaction(function.CreateTransactionInput(contractAddress)));
promise.Build(unityRequest, () => unityRequest.Result, NetworkProvider.GetNetworkChainUrl);
}
