Claims:Centralized Block Chain and Kryptom Coin , Description:Description of software
This software shows the proof of work for a Centralized Block Chain and based on the centralized network, which can be a better way in many respects, comprises only of parties whose identities are known. So anyone, unlike in decentralized block chain, cannot just join the network and leads into a system that has better validity as only credible and reputable participants may post to the ledger. Since the network participants identities are known, so their transactions can also be audited. Furthermore, centralized distributed ledger has its right potential to be used in the regulated industries like in BFSI Domain industries and financial services.
Kryptom
A new crypto currency is being proposed, coined as “Kryptom”. This currency is founded on the centralized Block Chain.
// $ go run blockchain.go
package main
import (
"fmt"
"crypto/sha256"
"encoding/hex"
"time"
"strconv"
)
type Block struct {
Time int64 // seconds since (unix) epoch (1970-01-01)
Data string
Prev string // use []byte/int256/uint256 ??
Hash string // use []byteint256/uint256 ??
}
// bin(ary) bytes and integer number to (conversion) string helpers
func binToStr( bytes []byte ) string {
return hex.EncodeToString( bytes )
}
func intToStr( num int64 ) string {
return strconv.FormatInt( num, 10 )
}
func calcHash( data string ) string {
hashed := sha256.Sum256( []byte(data) )
return binToStr( hashed[:] ) // note: [:] converts [32]byte to []byte
}
func NewBlock(data string, prev string) Block {
t := time.Now().Unix()
hash := calcHash( intToStr(t) + prev + data )
return Block { t, data, prev, hash }
}
func main() {
b0 := NewBlock( "Hello, Cryptos!",
"0000000000000000000000000000000000000000000000000000000000000000" )
b1 := NewBlock( "Hello, Cryptos! - Hello, Cryptos!", b0.Hash )
fmt.Println( b0 )
// {1522687834 Hello, Cryptos!
// 0000000000000000000000000000000000000000000000000000000000000000
// d85da0f449ff9ddc2c5ba638b23b9524381811227eb463b8c9e0be40dc1b1a8a}
fmt.Println( len( b0.Hash ))
// => 64
fmt.Println( len( b0.Prev ))
// => 64
fmt.Println( b1 )
// {1522687834 Hello, Cryptos! - Hello, Cryptos!
// d85da0f449ff9ddc2c5ba638b23b9524381811227eb463b8c9e0be40dc1b1a8a
// e48ba730165d88e15435483fc3a60714be526096a0c9a71ad10623340e33c7e3}
fmt.Println( len( b1.Hash ))
// => 64
fmt.Println( len( b1.Prev ))
// => 64
blockchain := []Block {b0, b1}
fmt.Println( blockchain )
// => [{1522687834 Hello, Cryptos!
// 0000000000000000000000000000000000000000000000000000000000000000
// d85da0f449ff9ddc2c5ba638b23b9524381811227eb463b8c9e0be40dc1b1a8a}
// {1522687834 Hello, Cryptos! - Hello, Cryptos!
// d85da0f449ff9ddc2c5ba638b23b9524381811227eb463b8c9e0be40dc1b1a8a
// e48ba730165d88e15435483fc3a60714be526096a0c9a71ad10623340e33c7e3}]
}
pragma solidity ^0.4.24;
import './Ownable.sol';
import './ERC20Interface.sol';
/**
* @Kryptom
**/
contract Bank is Ownable {
address public investmentAddr; // Investment contract address used to allow withdrawals
address public coinToken; // COIN token address.
address public cashToken; // CASH token address.
/**
* @param _coinToken address of the Coinvest token.
* @param _cashToken address of the CASH token.
**/
constructor(address _coinToken, address _cashToken)
public
{
coinToken = _coinToken;
cashToken = _cashToken;
}
/** ****************************** Only Investment ****************************** **/
/**
* @dev Investment contract needs to be able to disburse funds to users.
* @param _to Address to send funds to.
* @param _value Amount of funds to send to _to.
* @param _isCoin True if the crypto to be transferred is COIN, false if it is CASH.
**/
function transfer(address _to, uint256 _value, bool _isCoin)
external
returns (bool success)
{
require(msg.sender == investmentAddr);
ERC20Interface token;
if (_isCoin) token = ERC20Interface(coinToken);
else token = ERC20Interface(cashToken);
require(token.transfer(_to, _value));
return true;
}
/** ******************************* Only Owner ********************************** **/
/**
* @dev Owner may change the investment address when contracts are being updated.
* @param _newInvestment The address of the new investment contract.
**/
function changeInvestment(address _newInvestment)
external
onlyOwner
{
require(_newInvestment != address(0));
investmentAddr = _newInvestment;
}
/** ****************************** Only Coinvest ******************************* **/
/**
* @dev Allow the owner to take non-COIN Ether or tokens off of this contract if they are accidentally
sent.
* @param _tokenContract The address of the token to withdraw (0x0 if Ether)--cannot be COIN.
**/
function tokenEscape(address _tokenContract)
external
onlyCoinvest
{
require(_tokenContract != coinToken && _tokenContract != cashToken);
if (_tokenContract == address(0)) coinvest.transfer(address(this).balance);
else {
ERC20Interface lostToken = ERC20Interface(_tokenContract);
uint256 stuckTokens = lostToken.balanceOf(address(this));
lostToken.transfer(coinvest, stuckTokens);
}
}
}
pragma solidity ^0.4.24;
contract ERC20Interface {
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
pragma solidity ^0.4.24;
/**
* @title Ownable
* @dev The Ownable contract has an owner address, and provides basic authorization control
* functions, this simplifies the implementation of "user permissions".
*/
contract Ownable {
address public owner;
address public coinvest;
mapping (address => bool) public admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {
owner = msg.sender;
coinvest = msg.sender;
admins[owner] = true;
admins[coinvest] = true;
}
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
modifier onlyCoinvest() {
require(msg.sender == coinvest);
_;
}
modifier onlyAdmin() {
require(admins[msg.sender]);
_;
}
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
}
/**
* @dev Changes the Coinvest wallet that will receive funds from investment contract.
* @param _newCoinvest The address of the new wallet.
**/
function transferCoinvest(address _newCoinvest)
external
onlyCoinvest
{
require(_newCoinvest != address(0));
coinvest = _newCoinvest;
}
/**
* @dev Used to add admins who are allowed to add funds to the investment contract.
* @param _user The address of the admin to add or remove.
* @param _status True to add the user, False to remove the user.
**/
function alterAdmin(address _user, bool _status)
external
onlyCoinvest
{
require(_user != address(0));
require(_user != coinvest);
admins[_user] = _status;
}
}
Design – Logo