Here is Decentralized Capital’s website, their FAQ, and their Token Contracts page. Unfortunately you need to be verified to use this decentralised exchange. Here is their IDEX decentralised exchange screen: Here is their USD.DC verified smart contract deployed at 0x01a7018e6d1fde8a68d12f59b6532fb523b6259d: … Continue reading →

Posted in Blog | Tagged Decentralisation, Exchange, Smart Contract, Source Code | Leave a comment

Op Ed: Why Ethereum’s Hard Fork Will Cause Problems in the Coming Year

Posted on February 4, 2017 by bok

Op Ed: Why Ethereum’s Hard Fork Will Cause Problems in the Coming Year

Posted in Ethereum News | Tagged Ethereum, Fork, Governance, Hard Fork | Leave a comment

FinTech Investment in China Doubled in 2016, Declines in Europe, US

Posted on February 4, 2017 by bok

FinTech Investment in China Doubled in 2016, Declines in Europe, US

Posted in Other News | Tagged Fintech | Leave a comment

Liverpool Gets Its Own Digital Currency

Posted on February 4, 2017 by bok

Liverpool Gets Its Own Digital Currency

Posted in Other News | Tagged Digital Currency | Leave a comment

Ethereum Payment Channels Could Enter Production in 2017

Posted on February 4, 2017 by bok

Ethereum Payment Channels Could Enter Production in 2017

Posted in Ethereum News | Tagged Ethereum, Payment Channel, Scalability | Leave a comment

Decentralized Capital’s IDEX Is Live on the Mainnet! And A Quick Look At The Smart Contract Code

Posted on February 4, 2017 by bok

IDEX Is Live on the Mainnet!. Following is the verified source code from 0x63091244180ae240c87d1f528f5f269134cb07b3:

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

pragma solidity ^0.4.6;

contract Token {

bytes32 public standard;

bytes32 public name;

bytes32 public symbol;

uint256 public totalSupply;

uint8 public decimals;

bool public allowTransactions;

mapping (address => uint256) public balanceOf;

mapping (address => mapping (address => uint256)) public allowance;

function transfer(address _to, uint256 _value) returns (bool success);

function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success);

function approve(address _spender, uint256 _value) returns (bool success);

function transferFrom(address _from, address _to, uint256 _value) returns (bool success);

}

contract DVIP {

function feeFor(address from, address to, uint256 amount) constant external returns (uint256 value);

}

contract Assertive {

function assert(bool assertion) {

if (!assertion) throw;

}

contract Owned is Assertive {

address internal owner;

event SetOwner(address indexed previousOwner, address indexed newOwner);

function Owned () {

owner = msg.sender;

}

modifier onlyOwner {

assert(msg.sender == owner);

}

function setOwner(address newOwner) onlyOwner {

SetOwner(owner, newOwner);

owner = newOwner;

}

function getOwner() returns (address out) {

return owner;

}

contract Math is Assertive {

function safeMul(uint a, uint b) internal returns (uint) {

uint c = a * b;

assert(a == 0 || c / a == b);

return c;

}

function safeSub(uint a, uint b) internal returns (uint) {

assert(b <= a);

return a - b;

}

function safeAdd(uint a, uint b) internal returns (uint) {

uint c = a + b;

assert(c>=a && c>=b);

return c;

}

contract ExchangeWhitelist is Math, Owned {

mapping (address => mapping (address => uint256)) public tokens; //mapping of token addresses to mapping of account balances

struct Account {

bool authorized;

uint256 tier;

uint256 resetWithdrawal;

uint256 withdrawn;

}

mapping (address => Account) public accounts;

mapping (address => bool) public whitelistAdmins;

mapping (address => bool) public admins;

//ether balances are held in the token=0 account

mapping (bytes32 => uint256) public orderFills;

address public feeAccount;

address public dvipAddress;

address public feeMakeExporter;

address public feeTakeExporter;

event Order(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s);

event Cancel(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s);

event Trade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, address get, address give, bytes32 hash);

event Deposit(address token, address user, uint256 amount, uint256 balance);

event Withdraw(address token, address user, uint256 amount, uint256 balance);

function ExchangeWhitelist(address feeAccount_, address dvipAddress_) {

feeAccount = feeAccount_;

dvipAddress = dvipAddress_;

feeMakeExporter = 0x00000000000000000000000000000000000000f7;

feeTakeExporter = 0x00000000000000000000000000000000000000f8;

}

function setFeeAccount(address feeAccount_) onlyOwner {

feeAccount = feeAccount_;

}

function setDVIP(address dvipAddress_) onlyOwner {

dvipAddress = dvipAddress_;

}

function setAdmin(address admin, bool isAdmin) onlyOwner {

admins[admin] = isAdmin;

}

function setWhitelister(address whitelister, bool isWhitelister) onlyOwner {

whitelistAdmins[whitelister] = isWhitelister;

}

modifier onlyWhitelister {

if (!whitelistAdmins[msg.sender]) throw;

}

modifier onlyAdmin {

if (msg.sender != owner && !admins[msg.sender]) throw;

}

function setWhitelisted(address target, bool isWhitelisted) onlyWhitelister {

accounts[target].authorized = isWhitelisted;

}

modifier onlyWhitelisted {

if (!accounts[msg.sender].authorized) throw;

}

function() {

throw;

}

function deposit(address token, uint256 amount) payable {

if (token == address(0)) {

tokens[address(0)][msg.sender] = safeAdd(tokens[address(0)][msg.sender], msg.value);

} else {

if (msg.value != 0) throw;

tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);

if (!Token(token).transferFrom(msg.sender, this, amount)) throw;

}

Deposit(token, msg.sender, amount, tokens[token][msg.sender]);

}

function withdraw(address token, uint256 amount) {

if (tokens[token][msg.sender] < amount) throw;

tokens[token][msg.sender] = safeSub(tokens[token][msg.sender], amount);

if (token == address(0)) {

if (!msg.sender.send(amount)) throw;

} else {

if (!Token(token).transfer(msg.sender, amount)) throw;

}

Withdraw(token, msg.sender, amount, tokens[token][msg.sender]);

}

function balanceOf(address token, address user) constant returns (uint256) {

return tokens[token][user];

}

uint256 internal feeTake;

uint256 internal feeMake;

uint256 internal feeTerm;

function trade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s, uint256 amount) onlyWhitelisted {

//amount is in amountBuy terms

bytes32 hash = sha3(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user);

if (!(

ecrecover(hash,v,r,s) == user &&

block.number <= expires &&

safeAdd(orderFills[hash], amount) <= amountBuy &&

tokens[tokenBuy][msg.sender] >= amount &&

tokens[tokenSell][user] >= safeMul(amountSell, amount) / amountBuy

)) throw;

feeMake = DVIP(dvipAddress).feeFor(feeMakeExporter, msg.sender, 1 ether);

feeTake = DVIP(dvipAddress).feeFor(feeTakeExporter, user, 1 ether);

tokens[tokenBuy][msg.sender] = safeSub(tokens[tokenBuy][msg.sender], amount);

feeTerm = safeMul(amount, ((1 ether) - feeMake)) / (1 ether);

tokens[tokenBuy][user] = safeAdd(tokens[tokenBuy][user], feeTerm);

feeTerm = safeMul(amount, feeMake) / (1 ether);

tokens[tokenBuy][feeAccount] = safeAdd(tokens[tokenBuy][feeAccount], feeTerm);

feeTerm = safeMul(amountSell, amount) / amountBuy;

tokens[tokenSell][user] = safeSub(tokens[tokenSell][user], feeTerm);

feeTerm = safeMul(safeMul(((1 ether) - feeTake), amountSell), amount) / amountBuy / (1 ether);

tokens[tokenSell][msg.sender] = safeAdd(tokens[tokenSell][msg.sender], feeTerm);

feeTerm = safeMul(safeMul(feeTake, amountSell), amount) / amountBuy / (1 ether);

tokens[tokenSell][feeAccount] = safeAdd(tokens[tokenSell][feeAccount], feeTerm);

orderFills[hash] = safeAdd(orderFills[hash], amount);

Trade(tokenBuy, amount, tokenSell, amountSell * amount / amountBuy, user, msg.sender, hash);

}

bytes32 internal testHash;

uint256 internal amountSelln;

function testTrade(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, address user, uint8 v, bytes32 r, bytes32 s, uint256 amount, address sender) constant returns (uint8 code) {

testHash = sha3(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user);

if (tokens[tokenBuy][sender] < amount) return 1;

if (!accounts[sender].authorized) return 2;

if (!accounts[user].authorized) return 3;

if (ecrecover(testHash, v, r, s) != user) return 4;

amountSelln = safeMul(amountSell, amount) / amountBuy;

if (tokens[tokenSell][user] < amountSelln) return 5;

if (block.number > expires) return 6;

if (safeAdd(orderFills[testHash], amount) > amountBuy) return 7;

return 0;

}

function cancelOrder(address tokenBuy, uint256 amountBuy, address tokenSell, uint256 amountSell, uint256 expires, uint256 nonce, uint8 v, bytes32 r, bytes32 s, address user) {

bytes32 hash = sha3(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user);

if (ecrecover(hash,v,r,s) != msg.sender) throw;

orderFills[hash] = amountBuy;

Cancel(tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, msg.sender, v, r, s);

}

Posted in Blog | Tagged Decentralisation, Ethereum, Exchange, Source Code | Leave a comment

The difference between App Coins and Protocol Tokens

Posted on February 3, 2017 by bok

The difference between App Coins and Protocol Tokens

Posted in Ethereum News | Tagged Crowdfunding, Ethereum, Smart Contract, Tokens | Leave a comment

Construct 2017: Experts Ask ‘How Long Until Private Ledgers Go Live?

Posted on February 3, 2017 by bok

Construct 2017: Experts Ask ‘How Long Until Private Ledgers Go Live?

Posted in Other News | Tagged Blockchain, Permissioned | Leave a comment

Monthly Archives: February 2017

UK Giant Seeks Patent for Invention Mitigating Blockchain Attacks

Leading Australian Bitcoin exchange ACX acquiring DigitalX Direct customers

Decentralized Ethereum Job Market Colony is Now in Beta

Project Jasper: Lessons From Bank of Canada’s First Blockchain Project

More Chinese Exchanges Impose Bitcoin Withdrawal Delays

Blockchain will change everything, but only if we can find the right talent

Exploring Continuous Token Models: Towards a Million Networks of Value

Chinese Exchanges Suspend Withdrawals for One Month

EU Securities Watchdog: New DLT Regulations Would Be ‘Premature’

Blockchain: The Invisible Technology That’s Changing the World

Drugs, Code and ICOs: Monero’s Long Road to Blockchain Respect

SEC Begins Soliciting Comments On Bitcoin Investment Trust

Why Cities Will Soon Choose Digital Currency Over Fiat Money

New Bitcoin Caching Features Could Improve Block Verification

Why Segwit is Important For Trezor & Other Hardware Bitcoin Wallets

New York City Law Firm Experiments with Blockchain Smart Contracts

Why Poker, Dating Dapps Chose Ethereum

Dutch Tax Authority Clarifies: Bitcoin Mixing Will Not Be Banned, But Will Raise Suspicion

Why Bitcoin Unlimited’s “Emergent Consensus” Is a Gamble

Bitcoin Unlimited Support Overtakes SegWit For the First Time

Corda and the Distributed Ledger Technology

Golem Protocol Part I: Decentralized Exchange for Computing

Decentralized Capital’s Tokenised Fiat Currency. A Quick Look At The Smart Contracts

Op Ed: Why Ethereum’s Hard Fork Will Cause Problems in the Coming Year

FinTech Investment in China Doubled in 2016, Declines in Europe, US

Liverpool Gets Its Own Digital Currency

Ethereum Payment Channels Could Enter Production in 2017

Decentralized Capital’s IDEX Is Live on the Mainnet! And A Quick Look At The Smart Contract Code

The difference between App Coins and Protocol Tokens

Construct 2017: Experts Ask ‘How Long Until Private Ledgers Go Live?

Latest Blog Post

Latest Ethereum News

Latest Other News

Archives

Meta

Monthly Archives: February 2017

Tags

Archives

Meta