Topic: [TESTNET]Bismuth - New Language, Interpretation Engines, DAPPs - page 36. (Read 49748 times)

Should be easy, instead of a fraction of every blockreward going to the dev address, make it so that only every nth block does that.

For example, every 1000th block would send funds to the dev address.

Anyway, it's an interesting project. I hope this will be GPU mineable.

An alternative approach to ICO would be getting some fees or block rewards to the development address.
However, I have yet to come up with an efficient way of doing this, without spamming the network, the dev address might be a "special one" with different client rules than every other.

Poll added

Undecided, but it is true that I get motivated by money.

Thanks, we will see how it works out, I plan to release a public testnet soon. How to get some coins - there will probably be a crowdsale, but testers will be rewarded with 10% of all coins (if presale is agreed). So if you participate in the public test, you will get free coins. Also, you can do some mining using miner.exe/miner.py once the testnet is online. Also, an address you generate (one should be generated upon running node.exe/node.py) should be transferable between testnets and mainnet.

Oh wow, great idea and concept.

Watching with interest.  

Edit:- So how to get some coins?

Hello. At the moment, mining is an independent layer above the transaction engine. Transactions are blocks on their own and are only paid with fees. Each time you initiate a transaction, a new block is created. Feel free to ask further questions.

Mining: 25 Bismuth reward per 50 blocks (ETH has 5)

I don't understand. Every 50th block there is a reward of 25? What about the other 49 blocks?

ICO 

In a truly free world nice 

Watching, this one looks cool. Will check back later for future update.

Started this thread to get some initial feedback on the concept / code.
My node is not running at the moment, but you are free to try it on your own, post-genesis account is on GitHub.
Everything is subject to change.

Download

Installer or source: https://github.com/hclivess/Bismuth/releases

Technical details

• System: Proof of work (custom implementation)
• Hashing algorithm: SHA224, base64
• Signing algorithm: PKCS1_v1_5, base64
• Block size: ~650 bytes + decentralized app data
• Compressed block size: ~250 bytes
• Mining reward: 10 units + fees
• Difficulty: log(1e18 / timestamp difference over the last 30 blocks average)
• Difficulty retarget: average of last 30 blocks, every block
• Total tokens: 99,999,980 (1,099,99,978 including dev rewards)
• Smallest unit: 0.00000001
• Confirmations before respending: 0 (user decides)
• Default P2P port:
• Outgoing: Random
• Incoming (port forwarded): 2829
• Plaintext peerlist file
• Tor proxy support
• Source: https://github.com/hclivess/Bismuth
• Extreme efficiency: 20% CPU and 20MB RAM on an Intel Atom Compustick
• OpenField Decentralized Applications Platform
• Decentralized Application Execution Engine Philosophy

Dependencies:

• For Windows Executable: Microsoft Visual C++ 2010 Redistributable Package (x86) https://www.microsoft.com/en-us/download/details.aspx?id=5555
• To use tor, download Tor expert bundle (Win: https://www.torproject.org/dist/torbrowser/6.5.1/tor-win32-0.2.9.10.zip) and run tor.exe
• python 2.7
• pycrypto
• pillow
• pyqrcode
• pypng
• simple-crypt
• web.py
• win_inet_pton for Windows
• PySocks

How to run without the executables:

• Download and install https://www.python.org/ftp/python/2.7.11/python-2.7.11.msi
• Run "pip install pillow pyqrcode pypng pyinstaller web.py pycrypto simple-crypt win_inet_pton PySocks"
• Open node.py, optionally gui.py or miner.py

How to run on Linux

• sudo apt install python-pip
• sudo pip install pillow pyqrcode pypng pyinstaller web.py pycrypto simple-crypt python-socks
• sudo apt-get install python-tk
• Open node.py, optionally gui.py or miner.py

Distribution Proposal

• Bismuth: No presale, testnet rewards premine, rewards for devs

Introduction

My motivation for creating Bismuth is rooted in my desire to help the community. There were several NovaCoin-based projects
in the past which I wanted to save by contributing to their code, but the default Bitcoin cryptography, libraries,
code segmentation and language do not feel natural to me. So instead of learning the whole Bitcoin codebase, I decided
to recreate it in something even non-programmers understand. Something, which makes prototyping super simple and quick
and enables decentralized application deployment in hours - Python.

Welcome to Bismuth, a digital distributed self-regulating database system whose primary application is currency,
and its first application is mining. It comes with a DAPP out-of-the-box. Bismuth is not based on code of BTC or any of
it's derivates, it is only inspired by some ideas laid down by Andreas M. Antonopoulos, Satoshi Nakamoto (BitCoin),
Sunny King (Peercoin), NXT and ETH developers.

Bismuth does not draw any code from other repositories, instead it reformulates the cryptocurrency code in its own terms
to be easily readable, compatible across all platforms, integrated into business solutions with utmost ease and most
importantly open for development to wide public through it's simplicity, while minimizing the security risk for custom
code implementations.

Specifications

Bismuth differs from the mentioned systems in many ways and some concepts are different, in pursuit of improved performance
and removal of deliberate, non-technical limitations.

When the network is not used extensively, fees are almost non-existent. The fees are redistributed to miners. The risk
of double spending is mitigated through the longest chain rule, and every transaction is checked against balance.
Unlike the sophisticated input/output system, Bismuth uses a simple balance addition, subtraction and comparison.

Bismuth introduces a flat file mempool, which means no transactions are lost even when the system is restarted.
System chosen for databases is the sqlite3, default for every Python installation. It is ready on-the-fly
and easily  accessible through third party tools or the blockchain explorer, which is included with Bismuth.
Also, sqlite3 will make sidechain, dapp and hyperblock implementation very easy in the future.

There is a central transaction processing core in every node, which handles transaction verification and synchronization
and makes this system robust and reliable.

Another great feature for third party integration are the socket functions. This makes up for both Bitcoin's RPC and custom
APIs through unified and generic features on the fly in any programming language capable of handling  sockets. The format
is easily readable to humans.

Author of this paper believes that the main success of Bitcoin is due to mining, but due to social implications
and not the technical ones. Mining or Proof of Work corresponds is Bitcoin's first "killer app", because it
basically  represents a decentralized lottery. Electrical power is used as input, exchanged for a chance of reward.
For this reason, mining is included in Bismuth. Since the block hash includes a signature in it and changing variables
like timestamp or amount are used, hash must be different on each minimum time unit. Iterating hashes until a match
is found leads to successful mining. A miner is included with Bismuth (miner.py/miner.exe)

Future Development

Listed by simplest to implement, top to bottom

1. Message signing. The GUI is in place, but not working as of yet. Done

2. Bismuth's implementation of decentralized data and applications will be handled through technology which goes under the name OpenField. For this purpose, an extra column will be created in the database with arbitrary user data. Then it will be decided whether an external framework will be developed for handling this data or if it happens to be implemented to the core. Done

3. Compression mechanisms developed for Bismuth will make it even more efficient. Technology coined Extreme Blockchain Compression  (EBC), which uses database references of repeated data, is capable of reducing the database size by more than 60%.

4. Sidechains and hyperblocks will increase scalability thousandfold. Sidechains will be held in separate databases, allowing users to pick which one they would like to work with. This also adds an opportunity to create private blockchains.

5. hyperblocks can be understood as decentralized checkpoints. Based on predefined rules, all nodes will sum up balances once a certain block height occurs. Most entries in the blockchain preceding the checkpoint will become irrelevant and removable. Anonymity greatly increased.

License

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.


Testnet participation form (no longer needed):
http://goo.gl/forms/B9jQKM6WczmPEMP73
[/list][/list]