CryptoURANUS Economics


Saturday, January 18, 2020

Referance: Full-Monero-Node on Linux

Full-Monero-Node on Linux


Photo by Bruno Gl├Ątsch
With the rise of cryptocurrencies, financial privacy has become a hot topic.

Monero is currently the best in the field thanks to the fairly big anonymity set, mandatory privacy for all transactions, ring signatures, Ring CT, stealth addresses, and the future Kovri anonymization network.
Although Monero developers have mitigated most, if not all, privacy risks associated with connecting your wallet to a 3rd party node, to get a piece of mind it's recommended to run your own full node.
In this article, I'll go through steps to install and set up monero on Linux, mainly the latest Ubuntu 18.04 bionic.
However, the steps should be the same for any Debian-based distribution using systemd and fairly similar for other distros with the exception of the package manager (apt).
Sorry, no Mac or Windows.

1 Update the operating system

First, update the system packages:
sudo apt update && sudo apt-get upgrade

2 Install dependencies

Make sure you have git installed. If not, do it now:
sudo apt install git
Install the rest of dependencies:
sudo apt install build-essential cmake doxygen graphviz miniupnpc pkg-config libboost-all-dev libcurl4-openssl-dev libgtest-dev libminiupnpc-dev libreadline-dev libssl-dev libunbound-dev libunwind8-dev libzmq3-dev libzmq3-dev libpgm-dev libsodium-dev
Unfortunately, libgtest-dev doesn't come as binary on Ubuntu, so you'll have to compile it yourself:
cd /usr/src/gtest 
sudo cmake . 
sudo make -j2
sudo mv libg* /usr/lib/
How to Create a Monero Paper Wallet to Secure Your Coins

3 Download and build Monero

Create source directory if you haven't already:
mkdir ~/source
cd ~/source
Clone the repository and its submodules:
git clone --recursive monero
make -j2 release # -j4 for 4 threads etc
It may take a while to compile depending on your machine.
When finished, copy all the binaries to /usr/local/bin:
sudo cp ./build/release/bin/* /usr/local/bin/
Top 5 Reasons Monero Will Become the Most Widely Used Private and Anonymous Cryptocurrency

4 Set up the service

I've written a systemd service that automatically starts the node after a reboot or when crashed.
cd /lib/systemd/system
sudo wget chmod 644 monerod.service
Make sure to edit the file to match your environment.
You may want to raise block-sync-size to a higher number if you run on a decent hardware or omit it completely and let the daemon decide automatically.
My node failed to keep up with the chain height after the April's fork so I had to set it manually.
Next, create a config file:
mkdir ~/.bitmonero
cd ~/.bitmonero
touch monerod.conf
and add the following lines:
echo "data-dir=/home/satoshi/.bitmonero" >> monerod.conf
echo "log-file=/home/satoshi/.bitmonero/monero.log" >> monerod.conf
echo "log-level=0" >> monerod.conf
If you want to be able to connect your wallet from another machine, add the following:
echo "rpc-bind-ip=" >> monerod.conf
echo "rpc-bind-port=18081" >> monerod.conf
echo "rpc-login=veryLongAndRandomUsername:veryLongAndRandomPassword" >> monerod.conf
Don't forget to change rpc-login to your own one.

5 Run the service

Enable the systemd config and start the daemon:
sudo systemctl enable monerod
sudo service monerod start
You can check the progress with:
tail -f monero.log
or using a simpler output:
monerod --config-file /home/satoshi/.bitmonero/monerod.conf status
The synchronization may take from a few hours to a few days depending on your hardware.
Please be patient.

6 Allow incoming connections (optional)

You can allow two types of incoming connections to your node: P2P and RPC.
The first one lets other nodes download the chain from you. The latter lets a wallet connect to your node and retrieve info about its balance, transactions etc.
For the P2P connection run this command:
sudo iptables -I INPUT -p tcp --dport 18080 -j ACCEPT
For the RPC:
sudo iptables -I INPUT -p tcp --dport 18081 -j ACCEPT
Save the rules permanently:
sudo iptables-save
If you're behind a router, you will have to forward the ports to your machine.
Please refer to your router's manual.

7 Connect to the node with your wallet

Now test your connection from your wallet.
If you use the GUI wallet go to Settings and fill out Address and Port.
Next, under Manage Daemon click Show Advanced and type in the RPC login you've set in ~/.bitmonero/monerod.conf earlier.

In case of using the command line wallet, you may start it with the following:
monero-wallet-cli --wallet-file /path/to/your/wallet --trusted-daemon --daemon-address ip.of.your.node:18081 --daemon-login veryLongAndRandomUsername:veryLongAndRandomPassword
Personally, I prefer the command line wallet because it's cleaner and all you need, most of the time, is really just 3 or 4 commands.

The ones that you will likely use the most are:
  • show_transfers to view the list of all transactions
  • integrated_address to get a receiving address containing a payment ID
  • balance to view locked and unlocked balance
  • transfer <address> <amount> to make a payment
Type help to access the list of all commands.
As you can tell, setting up Monero full node from source is fairly easy if you have basic knowledge of the Linux command line.
Optionally, to make your node more secure and anonymous, you may want to run it behind torify or torsocks (essentially the same). Unfortunately, I haven't done it myself yet so you'll have to look elsewhere.
All in all, I hope you liked the tutorial.
Please let me know in the comments section below if you run into any issues.
We hope you like the post. Please share it with your followers. Thank you for your support!
Subscribe to our newsletter for weekly thoughts and tutorials. You'll receive a FREE e-book as a bonus!

Tuesday, September 10, 2019

Difference Between HDL VHDL, Verilog, SystemVerilog; UPF

Difference Between HDL VHDL, Verilog, SystemVerilog; UPF

OptEdited Article,

What is the Difference Between HDL, VHDL, Verilog, SystemVerilog; UPF? The Designers of electronic hardware describe the behavioral structure of system  circuit designs using hardware description languages (HDLs).

This, (HDL), is a specialized programming languages commonly known as today as VHDL, Verilog, SystemVerilog, and the added UPF language is the missing link.

SystemVerilog (which includes Verilog 2001), VHDL, and UPF are parsed and processed in two steps, analysis and elaboration. Mixed VHDL and SystemVerilog compilation is fully supported via UPF.

This Elaboration supports both static elaboration and RTL elaboration.

Static elaboration elaborates the entire language that specifically binds instances to modules, resolves library references, propagates defparams, unrolls generate statements, and checks all hierarchical names/function/task calls. The result after static elaboration is an elaborated parse tree, appropriate for application simulations.

RTL elaboration is limited to the synthesize subset of the language. In addition to the static elaboration tasks for this subset, it generates sequential networks through flipflop and latch detection, and Boolean extraction. The result after RTL elaboration is a netlist, appropriate for applications such as logic synthesis and formal verification.

The netlist database stores RTL and netlist designs in a language-independent simple model based on generic gates such as The DFF, The AND, The OR, The MUX , etc.. The netlist database is common to both VHDL and SystemVerilog and has an efficient and clean API for easy integration into any existing database or object model.
  • Very memory efficient. Average overall memory usage just 300 bytes/gate.
  • Full hierarchy support, with grouping/ungrouping, etc.
  • Support for buses.
  • Compact storage of file/line/column origination info from RTL parsers.
  • Simple and clean data model and procedural Interface for easy integration with your existing database.

HDL: hardware description language (HDL) , In computer engineering, is a specialized computer language used to describe the structure and behavior of electronic circuits, and most commonly, digital logic circuits. A hardware description language enables a precise, formal description of an electronic circuit that allows for the automated analysis and simulation of an electronic circuit. It also allows for the synthesis of a HDL description into a netlist (a specification of physical electronic components and how they are connected together), which can then be placed and routed to produce the set of masks used to create an integrated circuit.  A hardware description language looks much like a programming language such as C; it is a textual description consisting of expressions, statements and control structures. One important difference between most programming languages and HDLs is that HDLs explicitly include the notion of time. HDLs form an integral part of electronic design automation (EDA) systems, especially for complex circuits, such as application-specific integrated circuits, microprocessors, and programmable logic devices.

SystemVerilog, standardized as IEEE 1800, is a hardware description and hardware verification language used to model, design, simulate, test and implement electronic systems. SystemVerilog is based on Verilog and some extensions, and since 2008 Verilog is now part of the same IEEE standard. It is commonly used in the semiconductor and electronic design industry as an evolution of Verilog.
Verilog, standardized as IEEE 1364, is a hardware description language (HDL) used to model electronic systems. It is most commonly used in the design and verification of digital circuits at the register-transfer level of abstraction. It is also used in the verification of analog circuits and mixed-signal circuits, as well as in the design of genetic circuits.[1] In 2009, the Verilog standard (IEEE 1364-2005) was merged into the SystemVerilog standard, creating IEEE Standard 1800-2009. Since then, Verilog is officially part of the SystemVerilog language. The current version is IEEE standard 1800-2017.[2]

VHDL (VHSIC-HDL) (Very High Speed Integrated Circuit Hardware Description Language) is a hardware description language used in electronic design automation to describe digital and mixed-signal systems such as field-programmable gate arrays and integrated circuits. VHDL can also be used as a general purpose parallel programming language.

UPF:  Verific’s UPF parser supports the entire IEEE 1801 standard (UPF 1.0, 2.0, 2.1, 3.0) and creates a UPF data model.
The UPF Parser is an integral component of Verific’s Parser Platform and interacts seamlessly with Verific’s standard SystemVerilog, VHDL, and Liberty parsers.

It natively interfaces with Verific’s data structures, and also has the ability to interface with external (non-Verific) design data.

The UPF Parser/Analyzer performs syntax and semantic checking, resolving a UPF specification into a power intent model that can be traversed and queried.

Complete file / line / column information on UPF descriptions is maintained and Verific’s comprehensive error handler is included.

The UPF Elaborator applies the power intent model to the original HDL design.

The result is a power-aware netlist with new instantiations of power-related cells, as well as any required supply network and corresponding control path logic.

UPF concepts elaborated in an HDL design include logic and supply ports and nets, power switches, and retention, isolation, level-shifter and repeater cells.

Verific’s UPF parser is also easily integrated with external (non-Verific) data structures.

Analysis creates parse-trees and performs type-inferencing to resolve the meaning of identifiers.

The Parser/Analyzer modules support the entire SystemVerilog IEEE 1800 (including Verilog IEEE 1364), VHDL IEEE 1076, and UPF IEEE 1801 languages, all revisions, without any restrictions. The resulting parse trees / data models come with extensive APIs.

They differ from software programming languages because they include a means of describing propagation time and signal strengths.

These days, (2019-*), it would be impossible to design a complex system on a chip (SoC) for a mobile device or any other consumer electronics product without an HDL.

Each of the three HDLs has its own distinct style.

VHDL and Verilog implement register-transfer-level (RTL) abstractions.

When they were first introduced in the late 1980s, they were considered breakthrough technologies because they enabled engineers to work at a higher level of abstraction with RTL simulators.

Previously, engineers simulated their designs at the schematic or gate level.

SystemVerilog was developed to provide an evolutionary path from VHDL and Verilog to support the complexities of SoC designs.

It’s a bit of a hybrid—the language combines HDLs and a hardware verification language using extensions to Verilog, plus it takes an object-oriented programming approach.

SystemVerilog includes capabilities for test-bench development and assertion-based formal verification.

The U.S. Department of Defense funded VHDL, and Gateway Design Automation developed Verilog to drive the Verilog simulator.

Cadence Design Systems, once it acquired Gateway, placed the Verilog HDL into the public domain and it became an industry standard.

In the early 1990s, the electronics industry was forced to contend with the “language wars,” where competing factions in either the VHDL or Verilog camp competed for an engineer’s desktop mindset.

Both languages survived and now coexist, often in the same design flow -i.e.

Co-Design designed SystemVerilog, initially known as SUPERLOG.

After Synopsys acquired Co-Design, SUPERLOG/SystemVerilog was placed in the public domain as well.

All three are IEEE industry standards –– VHDL is IEEE 1076-2008, Verilog is IEEE 1364-2005 and SystemVerilog is IEEE 1800-2012.

The IEEE works cooperatively with the industry standards organization Accellera, which acts as its steward and develops many of IEEE’s technology standards for system-level design, modeling, and verification.

My company, (Rob Dekker, CTO & Founder, Verific Design Automation ), Verific Design Automation, has built parsers and elaborators for VHDL, Verilog, and SystemVerilog since 1999.

Comparing VHDL, Verilog, SystemVerilogVHDL and Verilog are considered general-purpose digital design languages, while SystemVerilog represents an enhanced version of Verilog.

Each has its own style and characteristics.

VHDL has roots in the Ada programming language in both concept and syntax, while Verilog’s roots can be tracked back to an early HDL called Hilo and the C programming language.

VHDL is a rich and strongly typed language, deterministic and more verbose than Verilog.

With Verilog and VHDL, engineers can represent the desired functionality as a software program.

Then the model is simulated to confirm the design will work as intended.

Any problems can be corrected in the model, and simulation will verify the correction.
As a result, designs written in VHDL are considered self-documenting.

Its syntax is non-C-like and engineers working in VHDL need to do extra coding to convert from one data type to another.

VHDL often catches errors missed by Verilog.

VHDL emphasizes unambiguous semantics and allows portability between tools.

Sample VHDL Code:
reg1: process (rst, clk)
    if  rst = '1' then
        q_reg <= (others => '0');
        q_i <= (others => '0');
    elsif  rising_edge(clk) then
        if  s_l = '1' then
        q_i(0) <= q_i(7);
        loop1:  for i in 6 downto 0 loop
            q_i(i + 1) <= q_i(i);
        end loop loop1;
        q_reg <= y;
        q_i <= q_reg;
        q_reg <= y;
        end if;
    end if;
    end process reg1;

Verilog is weakly typed and more concise with efficient notation.

It is deterministic.

All data types are predefined in Verilog and each has a bit-level representation.

Syntax is C-like.

Sample Verilog Code:
always @(posedge CLK or posedge RST)
  if (RST) begin
     q_reg = 0;  
 Q = 0;   
 end else if (S_L) begin
     Q[7:0] = {Q[6:0],Q[7]}; 
 q_reg = Y;
 end else begin
     Q = q_reg;  
 q_reg = Y;  

SystemVerilog includes a set of extensions to the Verilog HDL to help engineers design and verify larger and more complex designs.

In fact, many industry watchers consider it the first Hardware Description and Verification Language (HDVL), because it combines VHDL and Verilog features with those of Hardware Verification Languages (HVLs) Vera and e, as well as C and C++.

It’s targeted at RTL coding, using constrained random techniques for assertion-based and coverage-driven verification.

Sample SystemVerilog Code:
property p_push_error; 
    @ (posedge clk) 
   not (b_if.push && b_if.full && !b_if.pop); 
  endproperty : p_push_error
  ap_push_error_1 : assert property (p_push_error);
  property p_pop_error; 
   @ (posedge clk) 
   not (b_if.pop && b_if.empty); 
  endproperty : p_pop_error
  ap_pop_error_1 : assert property (p_pop_error);

always_ff @ (posedge clk) begin
    b_if.error <= (b_if.pop && b_if.empty) || (b_if.push && b_if.full && !b_if.pop);

Because of its structure, VDHL catches most errors early in the design process.

Verilog, on the other hand, enables engineers to quickly write models.

SystemVerilog attempts to capture the best features of both, and includes features of HVLs to support test-bench development and formal verification techniques.

Friday, September 6, 2019

ASIC: Defined in CryptoCurrency

ASIC: Defined in CryptoCurrency is an ASIC (application-specific integrated circuit) is a microchip designed for a special application, such as a particular kind of transmission protocol or a hand-held computer.

You might contrast it with general integrated circuits, such as the microprocessor and the random access memory chips in your PC.

ASICs are used in a wide-range of applications, including auto emission control, environmental monitoring, and personal digital assistants (PDAs).

An ASIC can be pre-manufactured for a special application or it can be custom manufactured (typically using components from a "building block" library of components) for a particular customer application.

Thursday, September 5, 2019

CryptoCurrency Jargon Definitions

HOME-Page CryptoCurrency Jargon, and Definitions


BitCoin Current Exchange Rate Chart:


  • A

  • B

  • C

  • D

  • E

  • F

  • G

  • H

  • I

  • J

  • K

  • L

  • M

    • N

    • O

      • P

      • R

      • S

      • T

      • U

      • V

      • W

      • Z