public void RecoverWalletSuccessfullyReturnsWalletModel()
{
Bitcoin.Wallet.Wallet wallet = new Bitcoin.Wallet.Wallet
{
Name = "myWallet",
Network = WalletHelpers.GetNetwork("mainnet")
};
var mockWalletWrapper = new Mock <IWalletManager>();
mockWalletWrapper.Setup(w => w.LoadWallet(It.IsAny <string>(), It.IsAny <string>())).Returns(wallet);
string dir = AssureEmptyDir("TestData/ControllersTests/RecoverWalletSuccessfullyReturnsWalletModel");
var dataFolder = new DataFolder(new NodeSettings {
DataDir = dir
});
var controller = new WalletController(mockWalletWrapper.Object, new Mock <IWalletSyncManager>().Object, It.IsAny <ConnectionManager>(), Network.Main, new Mock <ConcurrentChain>().Object, dataFolder);
// Act
var result = controller.Load(new WalletLoadRequest
{
Name = "myWallet",
FolderPath = "",
Password = ""
});
// Assert
mockWalletWrapper.VerifyAll();
var viewResult = Assert.IsType <OkResult>(result);
Assert.Equal(200, viewResult.StatusCode);
}
public Unity3dController(ILoggerFactory loggerFactory, IAddressIndexer addressIndexer,
IBlockStore blockStore, IChainState chainState, Network network, ICoinView coinView, WalletController walletController, ChainIndexer chainIndexer, INFTTransferIndexer NFTTransferIndexer,
IStakeChain stakeChain = null,
IContractPrimitiveSerializer primitiveSerializer = null, IStateRepositoryRoot stateRoot = null, IContractAssemblyCache contractAssemblyCache = null,
IReceiptRepository receiptRepository = null, ISmartContractTransactionService smartContractTransactionService = null, ILocalExecutor localExecutor = null)
{
Guard.NotNull(loggerFactory, nameof(loggerFactory));
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.addressIndexer = Guard.NotNull(addressIndexer, nameof(addressIndexer));
this.blockStore = Guard.NotNull(blockStore, nameof(blockStore));
this.chainState = Guard.NotNull(chainState, nameof(chainState));
this.network = Guard.NotNull(network, nameof(network));
this.coinView = Guard.NotNull(coinView, nameof(coinView));
this.walletController = Guard.NotNull(walletController, nameof(walletController));
this.chainIndexer = Guard.NotNull(chainIndexer, nameof(chainIndexer));
this.stakeChain = stakeChain;
this.NFTTransferIndexer = NFTTransferIndexer;
this.primitiveSerializer = primitiveSerializer;
this.stateRoot = stateRoot;
this.contractAssemblyCache = contractAssemblyCache;
this.receiptRepository = receiptRepository;
this.smartContractTransactionService = smartContractTransactionService;
this.localExecutor = localExecutor;
}
private void GenerateKeys(string seed)
{
// generate the RSA keypair for the address
AsymmetricCipherKeyPair rsaKeyPair = WalletController.GetRSAKeyPairFromSeed(seed);
RsaKeyParameters rsaPublicKey = rsaKeyPair.Public as RsaKeyParameters;
RsaPublicKey pbk = new RsaPublicKey()
{
Exponent = rsaPublicKey.Exponent.ToByteArrayUnsigned(),
Modulus = rsaPublicKey.Modulus.ToByteArrayUnsigned()
};
RsaPrivateCrtKeyParameters rsaPrivateKey = rsaKeyPair.Private as RsaPrivateCrtKeyParameters;
RsaPrivateKey prk = new RsaPrivateKey()
{
DP = rsaPrivateKey.DP.ToByteArrayUnsigned(),
DQ = rsaPrivateKey.DQ.ToByteArrayUnsigned(),
Exponent = rsaPrivateKey.Exponent.ToByteArrayUnsigned(),
Modulus = rsaPrivateKey.Modulus.ToByteArrayUnsigned(),
P = rsaPrivateKey.P.ToByteArrayUnsigned(),
PublicExponent = rsaPrivateKey.PublicExponent.ToByteArrayUnsigned(),
Q = rsaPrivateKey.Q.ToByteArrayUnsigned(),
QInv = rsaPrivateKey.QInv.ToByteArrayUnsigned()
};
this._testOutputHelper.WriteLine($"Public key: {pbk.ToHex()}");
this._testOutputHelper.WriteLine($"Private key: {prk.ToHex()}");
}
public void RecoverWalletSuccessfullyReturnsWalletModel()
{
WalletModel walletModel = new WalletModel
{
FileName = "myWallet",
Network = "MainNet",
Addresses = new List <string> {
"address1", "address2", "address3", "address4", "address5"
}
};
var mockWalletWrapper = new Mock <IWalletWrapper>();
mockWalletWrapper.Setup(wallet => wallet.Load(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(walletModel);
var controller = new WalletController(mockWalletWrapper.Object);
// Act
var result = controller.Load(new WalletLoadRequest
{
Name = "myName",
FolderPath = "",
Password = ""
});
// Assert
mockWalletWrapper.VerifyAll();
var viewResult = Assert.IsType <JsonResult>(result);
Assert.NotNull(viewResult.Value);
Assert.IsType <WalletModel>(viewResult.Value);
var model = viewResult.Value as WalletModel;
Assert.Equal("myWallet", model.FileName);
}
public void RecoverWalletSuccessfullyReturnsWalletModel()
{
Wallet.Wallet wallet = new Wallet.Wallet
{
Name = "myWallet",
Network = WalletHelpers.GetNetwork("mainnet")
};
var mockWalletWrapper = new Mock <IWalletManager>();
mockWalletWrapper.Setup(w => w.LoadWallet(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(wallet);
var controller = new WalletController(mockWalletWrapper.Object, new Mock <ITracker>().Object);
// Act
var result = controller.Load(new WalletLoadRequest
{
Name = "myWallet",
FolderPath = "",
Password = ""
});
// Assert
mockWalletWrapper.VerifyAll();
var viewResult = Assert.IsType <JsonResult>(result);
Assert.NotNull(viewResult.Value);
Assert.IsType <WalletModel>(viewResult.Value);
var model = viewResult.Value as WalletModel;
Assert.Equal("Main", model.Network);
}
void Start()
{
if (itemType != ItemsType.coin && itemType != ItemsType.yellowCard)
{
value = WalletController.getValue(itemType);
}
}
void android_purchaseSucceededEvent(GooglePurchase purchase)
{
if (purchase.purchaseState == GooglePurchase.GooglePurchaseState.Purchased)
{
if (purchase.productId == BillingItemsIds.coin_01)
{
WalletController.addCoins(100f);
}
else if (purchase.productId == BillingItemsIds.coin_02)
{
WalletController.addCoins(1000f);
}
else if (purchase.productId == BillingItemsIds.coin_03)
{
WalletController.addCoins(10000f);
}
else if (purchase.productId == BillingItemsIds.coin_04)
{
WalletController.addCoins(100000f);
}
BillingManager.consumeItem(purchase.productId);
StoreInterface.updateCoin();
}
}
private void addOnWallet()
{
switch (itemType)
{
case ItemsType.coin: {
WalletController.addCoin();
break;
}
case ItemsType.whistle: {
WalletController.addCoins(value);
break;
}
case ItemsType.yellowCard: {
WalletController.addYellowCard();
break;
}
default: {
WalletController.addItems(itemType, value);
break;
}
}
Destroy(this.gameObject);
}
public async Task IShouldCanSeeTheWalletExtract()
{
var viewModel = new ExtractViewModel();
var mockForWalletService = new Mock <IWalletApplicationService>();
mockForWalletService.Setup(d => d.GetExtract(It.IsAny <string>()))
.ReturnsAsync(viewModel)
.Verifiable();
var mockForHttpContextAccessor = new Mock <IHttpContextAccessor>();
mockForHttpContextAccessor.Setup(d => d.HttpContext.User.Identity.Name)
.Returns(It.IsAny <string>())
.Verifiable();
var controller = new WalletController(
mockForWalletService.Object,
mockForHttpContextAccessor.Object);
var result = await controller.Extract();
var resultOk = result as OkObjectResult;
var resultData = resultOk.Value as BalanceViewModel;
Assert.IsInstanceOfType(result, typeof(ActionResult));
Assert.AreEqual(resultOk.StatusCode, 200);
mockForWalletService.VerifyAll();
}
public void LoadWalletSuccessfullyReturnsWalletModel()
{
Bitcoin.Wallet.Wallet wallet = new Bitcoin.Wallet.Wallet
{
Name = "myWallet",
Network = WalletHelpers.GetNetwork("mainnet")
};
var mockWalletWrapper = new Mock <IWalletManager>();
mockWalletWrapper.Setup(w => w.RecoverWallet(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DateTime>(), null)).Returns(wallet);
var controller = new WalletController(mockWalletWrapper.Object, new Mock <IWalletSyncManager>().Object, It.IsAny <ConnectionManager>(), Network.Main, new Mock <ConcurrentChain>().Object);
// Act
var result = controller.Recover(new WalletRecoveryRequest
{
Name = "myWallet",
FolderPath = "",
Password = "",
Network = "MainNet",
Mnemonic = "mnemonic"
});
// Assert
mockWalletWrapper.VerifyAll();
var viewResult = Assert.IsType <OkResult>(result);
Assert.Equal(200, viewResult.StatusCode);
}
public void FileNotFoundExceptionandReturns404()
{
var mockWalletWrapper = new Mock <IWalletManager>();
mockWalletWrapper.Setup(wallet => wallet.LoadWallet(It.IsAny <string>(), It.IsAny <string>())).Throws <FileNotFoundException>();
string dir = AssureEmptyDir("TestData/ControllersTests/FileNotFoundExceptionandReturns404");
var dataFolder = new DataFolder(new NodeSettings {
DataDir = dir
});
var controller = new WalletController(mockWalletWrapper.Object, new Mock <IWalletSyncManager>().Object, It.IsAny <ConnectionManager>(), Network.Main, new Mock <ConcurrentChain>().Object, dataFolder);
// Act
var result = controller.Load(new WalletLoadRequest
{
Name = "myName",
FolderPath = "",
Password = ""
});
// Assert
mockWalletWrapper.VerifyAll();
var viewResult = Assert.IsType <ErrorResult>(result);
Assert.NotNull(viewResult);
Assert.Equal(404, viewResult.StatusCode);
}
public void CreateWalletSuccessfullyReturnsMnemonic()
{
Mnemonic mnemonic = new Mnemonic(Wordlist.English, WordCount.Twelve);
var mockWalletCreate = new Mock <IWalletManager>();
mockWalletCreate.Setup(wallet => wallet.CreateWallet(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Returns(mnemonic);
string dir = AssureEmptyDir("TestData/ControllersTests/CreateWalletSuccessfullyReturnsMnemonic");
var dataFolder = new DataFolder(new NodeSettings {
DataDir = dir
});
var controller = new WalletController(mockWalletCreate.Object, new Mock <IWalletSyncManager>().Object, It.IsAny <ConnectionManager>(), Network.Main, new Mock <ConcurrentChain>().Object, dataFolder);
// Act
var result = controller.Create(new WalletCreationRequest
{
Name = "myName",
FolderPath = "",
Password = "",
Network = ""
});
// Assert
mockWalletCreate.VerifyAll();
var viewResult = Assert.IsType <JsonResult>(result);
Assert.Equal(mnemonic.ToString(), viewResult.Value);
Assert.NotNull(result);
}
public void SetupBeforeEachTest()
{
this.accountRepository = A.Fake <IRepository <Account> >();
this.controller = new WalletController(this.accountRepository);
var context = A.Fake <HttpControllerContext>();
var configuration = A.Fake <HttpConfiguration>();
var route = configuration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
var routeData = new HttpRouteData(route, new HttpRouteValueDictionary {
{ "controller", "values" }
});
context.Configuration = configuration;
context.RouteData = routeData;
context.Controller = controller;
this.controller.ControllerContext = context;
this.controller.Request = new HttpRequestMessage(HttpMethod.Get, "http://localhost:51018/api/values/");
this.controller.Request.Properties.Add(HttpPropertyKeys.HttpConfigurationKey, context.Configuration);
this.controller.Request.Properties.Add(HttpPropertyKeys.HttpRouteDataKey, context.RouteData);
this.urlHelper = A.Fake <UrlHelper>();
this.controller.Url = this.urlHelper;
A.CallTo(() => this.urlHelper.Link("DefaultApi", A <object> ._)).Returns("http://api/1");
}
public void CreateWalletSuccessfullyReturnsMnemonic()
{
Mnemonic mnemonic = new Mnemonic(Wordlist.English, WordCount.Twelve);
var mockWalletCreate = new Mock <IWalletManager>();
mockWalletCreate.Setup(wallet => wallet.CreateWallet(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), null)).Returns(mnemonic);
var controller = new WalletController(mockWalletCreate.Object, new Mock <ITracker>().Object);
// Act
var result = controller.Create(new WalletCreationRequest
{
Name = "myName",
FolderPath = "",
Password = "",
Network = ""
});
// Assert
mockWalletCreate.VerifyAll();
var viewResult = Assert.IsType <JsonResult>(result);
Assert.Equal(mnemonic.ToString(), viewResult.Value);
Assert.NotNull(result);
}
public async Task Initialize()
{
// create test user
var user = new AppIdentityUser
{
Id = "TestUser",
UserName = "******",
Email = "*****@*****.**",
TwoFactorEnabled = true
};
var userManager = this._serviceProvider.GetRequiredService <UserManager <AppIdentityUser> >();
await userManager.CreateAsync(user, "Pass@word1");
// sign in test user
var httpContext = this._serviceProvider.GetRequiredService <IHttpContextAccessor>().HttpContext;
httpContext.User = new ClaimsPrincipal(
new ClaimsIdentity(new GenericIdentity(user.Email), new[] { new Claim("ID", user.Id) }));
httpContext.RequestServices = this._serviceProvider;
this.walletController = new WalletController(
this._serviceProvider.GetRequiredService <IWalletService>(),
userManager);
this.walletController.ControllerContext.HttpContext = httpContext;
}
//Setup
public unit_test_walletcontroller()
{
//Setting up In memory dbs.
userdb = new SqliteConnection("DataSource=:memory:");
passdb = new SqliteConnection("DataSource=:memory:");
walletdb = new SqliteConnection("DataSource=:memory:");
userdb.Open();
passdb.Open();
walletdb.Open();
//Setting up contexts.
var userbuild = new DbContextOptionsBuilder <UserModelContext>()
.UseSqlite(userdb).Options;
var passbuild = new DbContextOptionsBuilder <PassModelContext>()
.UseSqlite(passdb).Options;
var walletbuild = new DbContextOptionsBuilder <WalletContext>()
.UseSqlite(walletdb).Options;
var userContext = new UserModelContext(userbuild);
var passContext = new PassModelContext(passbuild);
var walletContext = new WalletContext(walletbuild);
//Drop and create
userContext.Database.EnsureDeleted();
userContext.Database.EnsureCreated();
passContext.Database.EnsureDeleted();
passContext.Database.EnsureCreated();
walletContext.Database.EnsureDeleted();
walletContext.Database.EnsureCreated();
//Seeding data to test on
SeedUsers.seedUsers(userContext, passContext, walletContext);
//Setting uut
_uut = new WalletController(walletContext);
}
public static void buyItemUtilits(Items _item, float _moneyItem)
{
if (_moneyItem <= WalletController.getValue(ItemsType.coin))
{
WalletController.removeItems(ItemsType.coin, _moneyItem);
foreach (Items _args in DictionaryItems.listItems)
{
if (_args.Item == ItemsType.redCard)
{
if (_item.Item == ItemsType.redCard)
{
_args.Level++;
}
}
else if (_args.Item == ItemsType.life)
{
if (_item.Item == ItemsType.life)
{
_args.Level++;
}
}
}
}
else
{
WarningManager.noMoney();
}
}
public Main()
{
controller = new MainController();
wallet = new WalletController();
action = new ActionController();
InitializeComponent();
}
// Use this for initialization
void Start()
{
walletController = oyagiObject.GetComponent <WalletController>();
atmController = atmObject.GetComponent <ATMController>();
timerController = timerObject.GetComponent <GameTimerController>();
resultLayerController = resultLayerObject.GetComponent <ResultLayerController>();
startCash = atmController.cash;
}
void OnTriggerEnter2D(Collider2D c)
{
if (c.tag == tagPullDeposit)
{
WalletController wallet = c.GetComponent <WalletController>();
PullDeposit(wallet);
}
}
public void useRedCard()
{
WalletController.removeRedCard();
PlayerBehavior.Get.immunize(true);
executionTimeManager.startManagerTime(runningTime);
}
public async Task Deposit_Deposit10_ReturnsOkAndPostDepositBalance()
{
//// Arrange
decimal postDepositBalance = 15;
Balance expectedBalance = new Balance()
{
Amount = postDepositBalance
};
BalanceResponse expectedBalanceResponse = new BalanceResponse()
{
Amount = postDepositBalance
};
decimal depositAmount = 10;
DepositRequest depositRequest = new DepositRequest {
Amount = depositAmount
};
// Setup Mocks
Mock <IWalletService> walletServiceMock = new Mock <IWalletService>();
Deposit deposit = new Deposit {
Amount = depositAmount
};
walletServiceMock
.Setup(walletService => walletService.DepositFundsAsync(deposit))
.Returns(Task.FromResult(expectedBalance));
IWalletService walletService = walletServiceMock.Object;
ILogger <WalletController> logger = Mock.Of <ILogger <WalletController> >();
IMapper mapper = Mock.Of <IMapper>(mapper => mapper.Map <Deposit>(depositRequest) == deposit &&
mapper.Map <BalanceResponse>(expectedBalance) == expectedBalanceResponse);
// Initialize SUT
WalletController walletController = new WalletController(logger, mapper, walletService);
//// Act
ActionResult <BalanceResponse> actionResult = await walletController.Deposit(depositRequest);
ActionResult actualActionResult = actionResult.Result;
//// Assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
BalanceResponse actualBalanceResponse = Assert.IsType <BalanceResponse>(okObjectResult.Value);
Assert.Equal(expectedBalanceResponse, actualBalanceResponse);
walletServiceMock.Verify(walletService => walletService.DepositFundsAsync(deposit), Times.Once);
walletServiceMock.VerifyNoOtherCalls();
}
public async Task Withdrawal_Withdraw20_ReturnsOkAndBalance5()
{
//// Arrange
decimal postWithdrawalBalanceAmount = 5;
Balance postWithdrawalBalance = new Balance()
{
Amount = postWithdrawalBalanceAmount
};
BalanceResponse expectedBalanceResponse = new BalanceResponse()
{
Amount = postWithdrawalBalanceAmount
};
decimal withdrawalAmount = 20;
WithdrawalRequest withdrawalRequest = new WithdrawalRequest {
Amount = withdrawalAmount
};
// Setup Mocks
Mock <IWalletService> walletServiceMock = new Mock <IWalletService>();
Withdrawal withdrawal = new Withdrawal {
Amount = withdrawalAmount
};
walletServiceMock
.Setup(walletService => walletService.WithdrawFundsAsync(withdrawal))
.Returns(Task.FromResult(postWithdrawalBalance));
IWalletService walletService = walletServiceMock.Object;
ILogger <WalletController> logger = Mock.Of <ILogger <WalletController> >();
IMapper mapper = Mock.Of <IMapper>(mapper => mapper.Map <Withdrawal>(withdrawalRequest) == withdrawal &&
mapper.Map <BalanceResponse>(postWithdrawalBalance) == expectedBalanceResponse);
// Initialize SUT
WalletController walletController = new WalletController(logger, mapper, walletService);
//// Act
ActionResult <BalanceResponse> actionResult = await walletController.Withdraw(withdrawalRequest);
ActionResult actualActionResult = actionResult.Result;
//// Assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
BalanceResponse actualBalanceResponse = Assert.IsType <BalanceResponse>(okObjectResult.Value);
Assert.Equal(expectedBalanceResponse, actualBalanceResponse);
walletServiceMock.Verify(walletService => walletService.WithdrawFundsAsync(withdrawal), Times.Once);
walletServiceMock.VerifyNoOtherCalls();
}
public WalletControllerTest(ContextFixture contextFixture)
{
var walletRepository = new WalletRepository(contextFixture.ApiContext);
var cryptoRepository = new CryptoRepository(contextFixture.ApiContext);
var emailEmailService = new EmailService();
var coinMarketCapApiService = new WalletOperationsService(emailEmailService);
_walletController = new WalletController(walletRepository, cryptoRepository, coinMarketCapApiService);
}
public void AssertGeneratedWalletCredentialsVerifyWithoutPassphrase()
{
string passphrase = ""; // cannot be null
Mnemonic mnemonic = WalletController.GenerateMnemonic(passphrase, Network.Main);
var isVerified = WalletController.VerifyWalletCredentials(mnemonic.ToString(), passphrase, Network.Main);
Assert.True(isVerified);
}
public PassphraseViewModel(IScreen hostScreen) : base(hostScreen)
{
SubmitCommand = ReactiveCommand.CreateFromObservable(() =>
{
var mnemonic = WalletController.GenerateMnemonic(Passphrase, Global.Network).ToString();
HostScreen.Router.Navigate.Execute(new MnemonicViewModel(hostScreen, mnemonic)).Subscribe();
return(Observable.Return(Unit.Default));
});
}
public async Task Balance_GetBalanceIs4_ReturnsOkAndBalance4()
{
//// Arrange
decimal currentBalanceAmount = 4;
Balance currentBalance = new Balance()
{
Amount = currentBalanceAmount
};
BalanceResponse expectedBalanceResponse = new BalanceResponse()
{
Amount = currentBalanceAmount
};
// Setup Mocks
Mock <ILogger <WalletController> > loggerMock = new Mock <ILogger <WalletController> >();
ILogger <WalletController> logger = loggerMock.Object;
Mock <IMapper> mapperMock = new Mock <IMapper>();
mapperMock
.Setup(mapper => mapper.Map <BalanceResponse>(currentBalance))
.Returns(expectedBalanceResponse);
IMapper mapper = mapperMock.Object;
Mock <IWalletService> walletServiceMock = new Mock <IWalletService>();
walletServiceMock
.Setup(walletService => walletService.GetBalanceAsync())
.Returns(Task.FromResult(currentBalance));
IWalletService walletService = walletServiceMock.Object;
// Initialize SUT
WalletController walletController = new WalletController(logger, mapper, walletService);
//// Act
ActionResult <BalanceResponse> actionResult = await walletController.Balance();
ActionResult actualActionResult = actionResult.Result;
/// Assert
OkObjectResult okObjectResult = Assert.IsType <OkObjectResult>(actionResult.Result);
BalanceResponse actualBalanceResponse = Assert.IsType <BalanceResponse>(okObjectResult.Value);
Assert.Equal(expectedBalanceResponse, actualBalanceResponse);
walletServiceMock.Verify(walletService => walletService.GetBalanceAsync(), Times.Once);
walletServiceMock.VerifyNoOtherCalls();
}
public void Create_WithFunds_Via_Controller()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractNode();
CoreNode scReceiver = builder.CreateSmartContractNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName);
scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
scReceiver.SetDummyMinerSecret(new BitcoinSecret(key, scReceiver.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.GenerateStratisWithMiner(maturity + 5);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * (maturity + 5) * 50, total);
SmartContractsController senderSmartContractsController = scSender.FullNode.NodeService <SmartContractsController>();
WalletController senderWalletController = scSender.FullNode.NodeService <WalletController>();
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/StorageDemo.cs");
Assert.True(compilationResult.Success);
var buildRequest = new BuildCreateContractTransactionRequest
{
AccountName = AccountName,
Amount = "30",
GasLimit = "10000",
GasPrice = "1",
ContractCode = compilationResult.Compilation.ToHexString(),
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
JsonResult result = (JsonResult)senderSmartContractsController.BuildCreateSmartContractTransaction(buildRequest);
var response = (BuildCreateContractTransactionResponse)result.Value;
scSender.CreateRPCClient().AddNode(scReceiver.Endpoint, true);
SmartContractSharedSteps.SendTransactionAndMine(scSender, scReceiver, senderWalletController, response.Hex);
ContractStateRepositoryRoot senderState = scSender.FullNode.NodeService <ContractStateRepositoryRoot>();
Assert.Equal((ulong)30 * 100_000_000, senderState.GetCurrentBalance(new Address(response.NewContractAddress).ToUint160(new SmartContractsRegTest())));
}
}
bool PullDeposit(WalletController wallet)
{
if (depositPullPrice <= cash)
{
audio.Play();
wallet.cash = wallet.cash + depositPullPrice;
cash = cash - depositPullPrice;
return(true);
}
return(false);
}
public void TestGetWalletInfo(long IdCode, bool expected)
{
var dbContext = DbContextMocker.GetDatabaseBTCContext(string.Format("WalletInfoDatabaseBTC{0}", IdCode.ToString()));
var controller = new WalletController(dbContext);
var response = controller.Get(IdCode) as SaleService.Model.WalletInfo;
dbContext.Dispose();
Assert.Equal(expected, response != null);
}
void Awake ()
{
// Singleton pattern
if (instance == null)
{
// Gameinstance related stuff here
/************************************/
// For static reference
instance = this;
// PaycastMask for ignoring the buildings
Layer = 0;
raycastIgnoreMask = 1 << Layer;
raycastIgnoreMask = ~raycastIgnoreMask;
// Instantiate all controllers
gridFieldController = new GridFieldController();
treeGroupController = new TreeGroupController();
buildingController = new BuildingController();
npcController = new NPCController();
// Nothing opened, nothing selected!
selectedBuilding = 123456;
selectedNPC = 123456;
isSelected = false;
isBuilding = false;
// Wallet related stuff here
/************************************/
// Number of wallets are determined by the number of Player Names
// How much starting cash is given to the constructor
walletController = new WalletController(2000);
}
else if(instance != this)
{
// Singleton pattern - destroy the new one if you want to make another GameController
Destroy(gameObject);
}
}