void Update()
{
switch (state)
{
case WalletState.Init:
{
state = WalletState.Sync;
StartCoroutine(SyncBalance());
break;
}
case WalletState.Update:
{
state = WalletState.Ready;
balanceLabel.text = balance.ToString() + " " + assetSymbol;
Debug.Log("balance: " + balanceLabel.text);
wifLabel.text = keys.WIF;
startBtn.interactable = true;
break;
}
}
}
// Perform basic initialization of node
public void init()
{
running = true;
// First create the data folder if it does not already exist
checkDataFolder();
renameStorageFiles(); // this function will be here temporarily for the next few version, then it will be removed to keep a cleaner code base
// debug
if (Config.networkDumpFile != "")
{
NetDump.Instance.start(Config.networkDumpFile);
}
NetworkUtils.configureNetwork(Config.externalIp, Config.serverPort);
// Load or Generate the wallet
if (!initWallet())
{
running = false;
DLTNode.Program.noStart = true;
return;
}
// Setup the stats console
statsConsoleScreen = new StatsConsoleScreen();
// Initialize the wallet state
walletState = new WalletState();
}
public Wallet(ILogger <Wallet> logger, IOptions <AllOptions> options)
{
_syncLock = new object();
_logger = logger;
_options = options.Value;
_state = WalletState.Empty;
}
static public void start()
{
// Initialize the crypto manager
CryptoManager.initLib();
// Prepare the wallet
string path = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
walletStorage = new WalletStorage(Path.Combine(path, Config.walletFile));
// Initialize the wallet state
walletState = new WalletState();
// Prepare the local storage
localStorage = new SPIXI.Storage.LocalStorage();
// Read the account file
localStorage.readAccountFile();
// Start the network queue
NetworkQueue.start();
// Prepare the stream processor
StreamProcessor.initialize();
// Start the keepalive thread
PresenceList.startKeepAlive();
// Setup a timer to handle routine updates
mainLoopTimer = new System.Timers.Timer(2500);
mainLoopTimer.Elapsed += new ElapsedEventHandler(onUpdate);
mainLoopTimer.Start();
}
private void OnUpdatingState(WalletState state)
{
lblWalletStatus.Content = WalletStateConverter.Localize(state);
refreshingTransactionHistory.ResetTime();
switch (state)
{
case WalletState.ConnectedPool:
case WalletState.ConnectedAndMining:
imgStatus.Source = new BitmapImage(new Uri(@"/XDagWallet;component/Resources/icon-status-online.png", UriKind.Relative));
break;
case WalletState.TransferPending:
imgStatus.Source = new BitmapImage(new Uri(@"/XDagWallet;component/Resources/icon-status-pending.png", UriKind.Relative));
break;
default:
imgStatus.Source = new BitmapImage(new Uri(@"/XDagWallet;component/Resources/icon-status-offline.png", UriKind.Relative));
break;
}
// Set up a timer to trigger
refreshWalletDataTimer.Start();
}
IEnumerator SyncBalance()
{
yield return(new WaitForSeconds(2));
var balances = api.GetAssetBalancesOf(this.keys);
this.balance = balances.ContainsKey(assetSymbol) ? balances[assetSymbol] : 0;
this.state = WalletState.Update;
}
IEnumerator SyncBalance()
{
yield return(new WaitForSeconds(2));
var balances = NeoAPI.GetBalance(NeoAPI.Net.Test, this.keys.address);
this.balance = balances.ContainsKey(assetSymbol) ? balances[assetSymbol] : 0;
this.state = WalletState.Update;
}
public void OnStateUpdated(string newState)
{
WalletState newStateEnum = WalletStateConverter.ConvertFromMessage(newState);
if (newStateEnum != WalletState.None && newStateEnum != walletState)
{
this.onUpdatingState?.Invoke(newStateEnum);
walletState = newStateEnum;
}
}
public void Disconnect()
{
if (_State == WalletState.Created)
{
return;
}
TryUpdateLocation();
_Group.Disconnect();
_Group.ConnectedNodes.Added -= ConnectedNodes_Added;
_State = WalletState.Created;
}
IEnumerator SyncBalance()
{
if (loggedIn)
{
yield return(new WaitForSeconds(2));
Debug.Log("getting balance for address: " + keys.address);
var balances = NeoAPI.GetBalance(NeoAPI.Net.Test, keys.address);
balance = balances.ContainsKey(assetSymbol) ? balances [assetSymbol] : 0;
state = WalletState.Update;
}
}
private void UpdateState(WalletState state)
{
ShowStatus(WalletStateConverter.Localize(state));
if (state == WalletState.ConnectedPool)
{
xdagWallet.State = state;
WalletWindow walletWindow = new WalletWindow(xdagWallet);
walletWindow.Show();
this.Close();
}
}
public static string Localize(WalletState state)
{
switch (state)
{
case WalletState.None:
return(Properties.Strings.WalletState_None);
case WalletState.Registering:
return(Properties.Strings.WalletState_Registering);
case WalletState.Idle:
return(Properties.Strings.WalletState_Idle);
case WalletState.LoadingBlocks:
return(Properties.Strings.WalletState_LoadingBlocks);
case WalletState.Stopped:
return(Properties.Strings.WalletState_Stopped);
case WalletState.ConnectingNetwork:
return(Properties.Strings.WalletState_ConnectingNetwork);
case WalletState.ConnectedNetwork:
return(Properties.Strings.WalletState_ConnectedNetwork);
case WalletState.ConnectingPool:
return(Properties.Strings.WalletState_ConnectingPool);
case WalletState.ConnectedPool:
return(Properties.Strings.WalletState_ConnectedPool);
case WalletState.ConnectedAndMining:
return(Properties.Strings.WalletState_ConnectedAndMining);
case WalletState.Synchronizing:
return(Properties.Strings.WalletState_Synchronizing);
case WalletState.Synchronized:
return(Properties.Strings.WalletState_Synchronized);
case WalletState.TransferPending:
return(Properties.Strings.WalletState_TransferPending);
case WalletState.ResetingEngine:
return(Properties.Strings.WalletState_ResetingEngine);
default:
return(string.Empty);
}
}
// Perform basic initialization of node
public void init()
{
running = true;
// First create the data folder if it does not already exist
checkDataFolder();
renameStorageFiles(); // this function will be here temporarily for the next few version, then it will be removed to keep a cleaner code base
// debug
if (Config.networkDumpFile != "")
{
NetDump.Instance.start(Config.networkDumpFile);
}
UpdateVerify.init(Config.checkVersionUrl, Config.checkVersionSeconds);
// Initialize storage
if (storage is null)
{
storage = IStorage.create(Config.blockStorageProvider);
}
if (!storage.prepareStorage())
{
Logging.error("Error while preparing block storage! Aborting.");
Program.noStart = true;
return;
}
NetworkUtils.configureNetwork(Config.externalIp, Config.serverPort);
// Load or Generate the wallet
if (!initWallet())
{
storage.stopStorage();
running = false;
DLTNode.Program.noStart = true;
return;
}
// Setup the stats console
statsConsoleScreen = new StatsConsoleScreen();
// Initialize the wallet state
walletState = new WalletState();
inventoryCache = new InventoryCacheDLT();
PeerStorage.init("");
}
public void Disconnect()
{
#pragma warning disable CS0612 // Type or member is obsolete
if (_State == WalletState.Created)
#pragma warning restore CS0612 // Type or member is obsolete
{
return;
}
TryUpdateLocation();
_Group.Disconnect();
_Group.ConnectedNodes.Added -= ConnectedNodes_Added;
#pragma warning disable CS0612 // Type or member is obsolete
_State = WalletState.Created;
#pragma warning restore CS0612 // Type or member is obsolete
}
public Amount Withdraw()
{
lock (_syncLock)
{
if (_state.Stake > Amount.Zero)
{
throw new InvalidOperationException("Cannot withdraw while there are money at stake.");
}
Amount result = _state.Balance;
LogState("Before withdraw");
_state = WalletState.Empty;
LogState("After withdraw");
return(result);
}
}
public Amount EndStake(int coefficient)
{
lock (_syncLock)
{
if (_state.Stake == Amount.Zero)
{
throw new InvalidOperationException("Cannot end stake while there are no money at stake.");
}
Amount profit = _state.Stake * (coefficient / (decimal)_coefficientPrecisionValue);
LogState("Before end stake");
_state = new WalletState(balance: _state.Balance + profit, stake: Amount.Zero);
LogState("After end stake");
return(profit);
}
}
public void Deposit(Amount deposit)
{
lock (_syncLock)
{
if (_state.Balance > Amount.Zero)
{
throw new InvalidOperationException("Cannot deposit while balance is not zero.");
}
if (_state.Stake > Amount.Zero)
{
throw new InvalidOperationException("Cannot deposit while there are money at stake.");
}
LogState("Before deposit");
_state = new WalletState(balance: deposit, stake: Amount.Zero);
LogState("After deposit");
}
}
/// <summary>
/// Start the connection to the NodeGroup
/// </summary>
public void Connect()
{
AssertGroupAffected();
if (State != WalletState.Created)
{
throw new InvalidOperationException("The wallet is already connecting or connected");
}
_State = WalletState.Disconnected;
_Group.Connect();
_Group.ConnectedNodes.Added += ConnectedNodes_Added;
foreach (var node in _Group.ConnectedNodes)
{
if (FindWalletBehavior(node.Behaviors) == null)
{
node.DisconnectAsync("The node is not configured for wallet");
}
}
}
// Perform basic initialization of node
static public void init()
{
running = true;
// Load or Generate the wallet
if (!initWallet())
{
running = false;
S2.Program.noStart = true;
return;
}
// Setup the stats console
statsConsoleScreen = new StatsConsoleScreen();
// Initialize the wallet state
walletState = new WalletState();
}
void Update()
{
switch (state)
{
case WalletState.Init:
{
state = WalletState.Sync;
StartCoroutine(SyncBalance());
break;
}
case WalletState.Update:
{
this.state = WalletState.Ready;
this.balanceLabel.text = balance.ToString() + " " + assetSymbol;
this.startBtn.interactable = true;
break;
}
}
}
// Perform basic initialization of node
private void init()
{
running = true;
// Network configuration
NetworkUtils.configureNetwork(Config.externalIp, Config.serverPort);
// Load or Generate the wallet
if (!initWallet())
{
running = false;
S2.Program.noStart = true;
return;
}
// Setup the stats console
statsConsoleScreen = new StatsConsoleScreen();
// Initialize the wallet state
walletState = new WalletState();
}
// Perform basic initialization of node
static public void init()
{
running = true;
// Upgrade any legacy files
NodeLegacy.upgrade();
// Load or Generate the wallet
if (!initWallet())
{
running = false;
DLTNode.Program.noStart = true;
return;
}
// Setup the stats console
statsConsoleScreen = new StatsConsoleScreen();
// Initialize the wallet state
walletState = new WalletState();
}
#pragma warning restore CS0612 // Type or member is obsolete
/// <summary>
/// Start the connection to the NodeGroup
/// </summary>
public void Connect()
{
AssertGroupAffected();
#pragma warning disable CS0612 // Type or member is obsolete
if (State != WalletState.Created)
#pragma warning restore CS0612 // Type or member is obsolete
{
throw new InvalidOperationException("The wallet is already connecting or connected");
}
#pragma warning disable CS0612 // Type or member is obsolete
_State = WalletState.Disconnected;
#pragma warning restore CS0612 // Type or member is obsolete
_Group.Connect();
_Group.ConnectedNodes.Added += ConnectedNodes_Added;
foreach (var node in _Group.ConnectedNodes)
{
if (FindWalletBehavior(node.Behaviors) == null)
{
node.DisconnectAsync("The node is not configured for wallet");
}
}
}
public StakeResult TryStake(Amount stake)
{
lock (_syncLock)
{
if (_state.Stake > Amount.Zero)
{
throw new InvalidOperationException("Cannot stake again while there are already money at stake.");
}
if (stake == Amount.Zero)
{
return new StakeResult {
InvalidStake = true
}
}
;
if (stake > _state.Balance)
{
return new StakeResult {
InsufficientBalance = true
}
}
;
Amount maxStake = (Amount.Max - _state.Balance) / _maxStakeDivisionArgument;
if (stake > maxStake)
{
return(new StakeResult {
MoreThanMaxStake = true, MaxStake = maxStake
});
}
LogState("Before stake");
_state = new WalletState(balance: _state.Balance - stake, stake: stake);
LogState("After stake");
return(new StakeResult {
IsSuccess = true
});
}
}
public void Disconnect()
{
if(_State == WalletState.Created)
return;
TryUpdateLocation();
_Group.Disconnect();
_Group.ConnectedNodes.Added -= ConnectedNodes_Added;
_State = WalletState.Created;
}
/// <summary>
/// Start the connection to the NodeGroup
/// </summary>
public void Connect()
{
AssertGroupAffected();
if(State != WalletState.Created)
throw new InvalidOperationException("The wallet is already connecting or connected");
_State = WalletState.Disconnected;
_Group.Connect();
_Group.ConnectedNodes.Added += ConnectedNodes_Added;
foreach(var node in _Group.ConnectedNodes)
{
if(FindWalletBehavior(node.Behaviors) == null)
node.DisconnectAsync("The node is not configured for wallet");
}
}
/// <summary>
/// Connect the wallet with the given connection parameters
/// </summary>
/// <param name="parameters"></param>
public void Connect(NodeConnectionParameters parameters)
{
if(State != WalletState.Created)
throw new InvalidOperationException("The wallet is already connecting or connected");
var group = NodesGroup.GetNodeGroup(parameters);
if(group == null)
{
group = new NodesGroup(_Parameters.Network, parameters);
}
parameters = group.NodeConnectionParameters;
group.Requirements.MinVersion = ProtocolVersion.PROTOCOL_VERSION;
group.Requirements.RequiredServices = NodeServices.Network;
var chain = parameters.TemplateBehaviors.Find<ChainBehavior>();
if(chain == null)
{
chain = new ChainBehavior(new ConcurrentChain(_Parameters.Network));
parameters.TemplateBehaviors.Add(chain);
}
if(chain.Chain.Genesis.HashBlock != _Parameters.Network.GetGenesis().GetHash())
throw new InvalidOperationException("ChainBehavior with invalid network chain detected");
var addrman = parameters.TemplateBehaviors.Find<AddressManagerBehavior>();
if(addrman == null)
{
addrman = new AddressManagerBehavior(new AddressManager());
parameters.TemplateBehaviors.Add(addrman);
}
var tracker = parameters.TemplateBehaviors.Find<TrackerBehavior>();
if(tracker == null)
{
tracker = new TrackerBehavior(new Tracker(), chain.Chain);
parameters.TemplateBehaviors.Add(tracker);
}
_Chain = chain.Chain;
_AddressManager = addrman.AddressManager;
_Tracker = tracker.Tracker;
_TrackerBehavior = tracker;
_Group = group;
if(AddKnownScriptToTracker())
_Group.Purge("Bloom filter renew");
_State = WalletState.Disconnected;
_Group.Connect();
_Group.ConnectedNodes.Added += ConnectedNodes_Added;
_Group.ConnectedNodes.Removed += ConnectedNodes_Added;
foreach(var node in _Group.ConnectedNodes)
{
node.Behaviors.Find<TrackerBehavior>().Scan(_ScanLocation, Created);
}
}
/// <summary>
/// Connect the wallet with the given connection parameters
/// </summary>
/// <param name="group">The group to use</param>
public void Connect(NodesGroup group)
{
if (group == null)
{
throw new ArgumentNullException("group");
}
if (State != WalletState.Created)
{
throw new InvalidOperationException("The wallet is already connecting or connected");
}
var parameters = group.NodeConnectionParameters;
group.Requirements.MinVersion = ProtocolVersion.PROTOCOL_VERSION;
group.Requirements.RequiredServices |= NodeServices.Network;
var chain = parameters.TemplateBehaviors.Find <ChainBehavior>();
if (chain == null)
{
chain = new ChainBehavior(new ConcurrentChain(_Parameters.Network));
parameters.TemplateBehaviors.Add(chain);
}
if (chain.Chain.Genesis.HashBlock != _Parameters.Network.GetGenesis().GetHash())
{
throw new InvalidOperationException("ChainBehavior with invalid network chain detected");
}
var addrman = parameters.TemplateBehaviors.Find <AddressManagerBehavior>();
if (addrman == null)
{
addrman = new AddressManagerBehavior(new AddressManager());
parameters.TemplateBehaviors.Add(addrman);
}
var tracker = parameters.TemplateBehaviors.Find <TrackerBehavior>();
if (tracker == null)
{
tracker = new TrackerBehavior(new Tracker(), chain.Chain);
parameters.TemplateBehaviors.Add(tracker);
}
_Chain = chain.Chain;
_AddressManager = addrman.AddressManager;
_Tracker = tracker.Tracker;
_TrackerBehavior = tracker;
_Group = group;
if (AddKnownScriptToTracker())
{
_Group.Purge("Bloom filter renew");
}
_State = WalletState.Disconnected;
_Group.Connect();
_Group.ConnectedNodes.Added += ConnectedNodes_Added;
_Group.ConnectedNodes.Removed += ConnectedNodes_Added;
foreach (var node in _Group.ConnectedNodes)
{
node.Behaviors.Find <TrackerBehavior>().Scan(_ScanLocation, Created);
}
}
