private static void RunSend(RepositoryConfiguration repositoryConfig)
{
var repoFactory = new VakapayRepositoryMysqlPersistenceFactory(repositoryConfig);
var ethereumBusiness = new EthereumBusiness.EthereumBusiness(repoFactory);
var connection = repoFactory.GetDbConnection();
try
{
while (true)
{
Console.WriteLine("Start Send Ethereum....");
var rpc = new EthereumRpc(AppSettingHelper.GetEthereumNode());
using (var ethereumRepo = repoFactory.GetEthereumWithdrawTransactionRepository(connection))
{
var resultSend = ethereumBusiness.SendTransactionAsync(ethereumRepo, rpc);
Console.WriteLine(JsonHelper.SerializeObject(resultSend.Result));
Console.WriteLine("Send Ethereum End...");
Thread.Sleep(1000);
}
}
}
catch (Exception e)
{
connection.Close();
Console.WriteLine(e.ToString());
}
}
public WalletBusiness(IVakapayRepositoryFactory vakapayRepositoryFactory, bool isNewConnection = true)
{
_vakapayRepositoryFactory = vakapayRepositoryFactory;
_connectionDb = isNewConnection
? _vakapayRepositoryFactory.GetDbConnection()
: _vakapayRepositoryFactory.GetOldConnection();
ethereumBussiness = new EthereumBusiness.EthereumBusiness(vakapayRepositoryFactory, false);
bitcoinBussiness = new BitcoinBusiness.BitcoinBusiness(vakapayRepositoryFactory, false);
vakacoinBussiness = new VakacoinBusiness.VakacoinBusiness(vakapayRepositoryFactory, false);
sendMailBusiness = new SendMailBusiness.SendMailBusiness(_vakapayRepositoryFactory, false);
userBusiness = new UserBusiness.UserBusiness(_vakapayRepositoryFactory, false);
portfolioHistoryBusiness =
new PortfolioHistoryBusiness.PortfolioHistoryBusiness(_vakapayRepositoryFactory, false);
//(PortfolioHistoryBusiness.PortfolioHistoryBusiness)_vakapayRepositoryFactory.GetPortfolioHistoryRepository(_connectionDb);
}
private static void RunScan(RepositoryConfiguration repositoryConfig)
{
var repoFactory = new VakapayRepositoryMysqlPersistenceFactory(repositoryConfig);
var ethereumBusiness = new EthereumBusiness.EthereumBusiness(repoFactory);
var walletBusiness = new WalletBusiness.WalletBusiness(repoFactory);
var connection = repoFactory.GetOldConnection() ?? repoFactory.GetDbConnection();
try
{
while (true)
{
Console.WriteLine("==========Start Scan Ethereum==========");
var rpc = new EthereumRpc(AppSettingHelper.GetEthereumNode());
using (var ethereumRepo = repoFactory.GetEthereumWithdrawTransactionRepository(connection))
{
using (var ethereumDepoRepo = repoFactory.GetEthereumDepositeTransactionRepository(connection))
{
var resultSend =
ethereumBusiness
.ScanBlockAsync <EthereumWithdrawTransaction, EthereumDepositTransaction,
EthereumBlockResponse, EthereumTransactionResponse>(CryptoCurrency.ETH, walletBusiness,
ethereumRepo, ethereumDepoRepo, rpc);
Console.WriteLine(JsonHelper.SerializeObject(resultSend.Result));
Console.WriteLine("==========Scan Ethereum End==========");
Console.WriteLine("==========Wait for next scan==========");
Thread.Sleep(5000);
}
}
}
}
catch (Exception e)
{
connection.Close();
Console.WriteLine(e.ToString());
}
}
private static void RunScan(RepositoryConfiguration repositoryConfig)
{
var repoFactory = new SmartContractRepositoryMysqlPersistenceFactory(repositoryConfig);
var ethereumBusiness = new EthereumBusiness.EthereumBusiness(repoFactory);
var rpc = new EthereumRpc(AppSettingHelper.GetEthereumNode());
rpc.GetBlockNumber();
var result = rpc.GetBlockNumber();
if (result.Status == Status.STATUS_ERROR)
{
throw new Exception("Cant GetBlockNumber");
}
int blockNumber = 0;
if (!int.TryParse(result.Data, out blockNumber))
{
throw new Exception("Cant parse block number");
}
CacheHelper.SetCacheString(String.Format(RedisCacheKey.KEY_SCANBLOCK_LASTSCANBLOCK,
CryptoCurrency.ETH), blockNumber.ToString());
// var walletBusiness = new WalletBusiness.WalletBusiness(repoFactory);
var connection = repoFactory.GetOldConnection() ?? repoFactory.GetDbConnection();
try
{
while (true)
{
Console.WriteLine("==========Start Scan Ethereum==========");
// var rpc = new EthereumRpc(AppSettingHelper.GetEthereumNode());
// var _re = rpc.FindTransactionByHash("0xe62ea756f9dbb5eb2439ea946eab1a3413c5517ebe6eecfb6d067a5d849fcf1f");
// foreach(var tran in _re.)
//var _input = rpc.DecodeInput("0xa9059cbb0000000000000000000000003a2e25cfb83d633c184f6e4de1066552c5bf45170000000000000000000000000000000000000000000000008ac7230489e80000");
using (var ethereumRepo = repoFactory.GetEthereumWithdrawTransactionRepository(connection))
{
using (var ethereumDepoRepo = repoFactory.GetEthereumDepositeTransactionRepository(connection))
{
var resultSend =
ethereumBusiness
.ScanBlockAsync <models.Entities.ETH.EthereumTransaction.EthereumWithdrawTransaction, models.Entities.ETH.EthereumTransaction.EthereumDepositTransaction,
models.Entities.ETH.EthereumBlockResponse, EthereumTransactionResponse>(CryptoCurrency.ETH,
ethereumRepo, ethereumDepoRepo, rpc);
Console.WriteLine(JsonHelper.SerializeObject(resultSend.Result));
Console.WriteLine("==========Scan Ethereum End==========");
Console.WriteLine("==========Wait for next scan==========");
Thread.Sleep(50000);
}
}
}
}
catch (Exception e)
{
connection.Close();
Console.WriteLine(e.ToString());
}
}
/// <summary>
/// Created Address with optimistic lock
/// </summary>
/// <param name="rpcClass"></param>
/// <param name="walletId"></param>
/// <param name="other"></param>
/// <returns></returns>
public async Task <ReturnObject> CreateAddressAsync()
{
try
{
using (var dbConnection = _smartcontractRepositoryFactory.GetDbConnection())
{
if (dbConnection.State != ConnectionState.Open)
{
dbConnection.Open();
}
var userRepository = _smartcontractRepositoryFactory.GetUserRepository(dbConnection);
var userPendding = userRepository.FindUserAddressNull();
if (userPendding?.mem_id == null)
{
return new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = "User Not Found"
}
}
;
//begin first email
var transctionScope = dbConnection.BeginTransaction();
try
{
var lockResult = await userRepository.LockForProcessUser(userPendding);
if (lockResult.Status == Status.STATUS_ERROR)
{
transctionScope.Rollback();
return(new ReturnObject
{
Status = Status.STATUS_SUCCESS,
Message = "Cannot Lock For Process"
});
}
transctionScope.Commit();
}
catch (Exception e)
{
transctionScope.Rollback();
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = e.ToString()
});
}
//update Version to Model
userPendding.Version += 1;
var transactionSend = dbConnection.BeginTransaction();
try
{
var ethRpc = new EthereumRpc(AppSettingHelper.GetEthereumNode());
var pass = CommonHelper.RandomString(15);
var ethereumBusiness =
new EthereumBusiness.EthereumBusiness(_smartcontractRepositoryFactory);
var resultEthereum = ethereumBusiness.CreateAddress(ethRpc, userPendding.mem_id, pass);
if (resultEthereum.Status == Status.STATUS_ERROR)
{
transactionSend.Rollback();
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = "Cannot create add bitcoin"
});
}
var address = resultEthereum.Data;
if (string.IsNullOrEmpty(address))
{
transactionSend.Rollback();
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = "Cannot create address"
});
}
userPendding.IsProcessing = 0;
userPendding.mem_address = address;
userPendding.Status = Status.STATUS_COMPLETED;
var updateResult = userRepository.UpdateUser(userPendding);
if (updateResult.Status == Status.STATUS_ERROR)
{
transactionSend.Rollback();
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = "Cannot update wallet status"
});
}
transactionSend.Commit();
return(new ReturnObject
{
Status = Status.STATUS_SUCCESS,
Message = "Create success"
});
}
catch (Exception e)
{
// release lock
transactionSend.Rollback();
var releaseResult = await userRepository.ReleaseLock(userPendding);
Console.WriteLine(JsonHelper.SerializeObject(releaseResult));
throw;
}
}
}
catch (Exception e)
{
return(new ReturnObject
{
Status = Status.STATUS_ERROR,
Message = e.Message
});
}
}
