Angel \”Java\” Lopez on Blog

July 20, 2017

Blockchain: Links And Resources (47)

Filed under: Bitcoin, Blockchain, Ethereum, Smart Contracts, Solidity, Uncategorized — ajlopez @ 2:48 pm

Previous Post

Underhanded Solidity Coding Contest

Solidity CRUD- Part 1

Más usos para la tecnología de las monedas virtuales

What is Bitcoin Mining?

Announcing “Around the Block”: a Documentary Series about the Minds Behind the Blockchains

Potential network disruption

Formal Verification of Ethereum Smart Contracts

Functional Alternative to Ethereum (in Haskell)–Fae

Don’t Get CoinDashed — How to Secure Your Token Sale

A Brief History of Blockchain: An Investor’s Perspective

Stay tuned!

Angel “Java” Lopez


July 19, 2017

Blockchain: Links And Resources (46)

Filed under: Bitcoin, Blockchain, Ethereum, Smart Contracts, Solidity — ajlopez @ 2:42 pm

Previous Post
Next Post

Securify Formal Verification of Ethereum Smart Contracts

Formal Verification of Ethereum Smart Contracts

Arthur Gervais

Ben Davenport, CTO at BitGo

BitGo Making digital currencies usable for business

Suhas Daftuar Chaincode Labs

Ethereum contract for Bitcoin SPV

Solidity BTC Parser

Solidity Test

Browser-Only Solidity IDE and Runtime Environment

The ethereum VM implemented in JavaScript

Stay tuned!

Angel “Java” Lopez

July 16, 2017

Learning Ethereum/RSK (2)

Filed under: Bitcoin, Blockchain, Ethereum, RSK — ajlopez @ 3:30 pm

Previous Post

Before understanding in deep Ethereum and RSK projects, we must study Bitcoin, its ideas and ecosystem. Another book about Bitcoin is:

Learning Bitcoin

by Richard Caetano (blog) CEO and co-founder of Stratumn. Bitcoin and Blockchain adopter since 2011.

I read:

In this book, we will introduce Bitcoin with a hands-on approach. We will begin with a simple and easy-to-follow introduction, which includes buying and selling bitcoin. Throughout the middle, we will look into the internal workings of Bitcoin to understand how its various pieces work. Towards the end, we will explore various ways in which Bitcoin can be used as “programmable money”.

So, it’s not a book only dedicated to developers, it includes some interesting topics, like accessing Bitcoin from JavaScript tools, and a detailed description of mining process.

The author discuss:

  • Setting  up a wallet
  • Buying and selling Bitcoins
  • Protecting your Bitcoins
  • Understanding the Blockchain (a topic more related with our objetives, understand Ethereum and RSK) Transactions, blocks, keys, genesis block. He also describes attacks like the 51 percent, race, and Finney attacks.
  • Installing a Bitcoin Node
  • Understanding the Mining Process (another topic to take into account in our exploration) Proof of work, mining rewards, mining pools, setting up a mining client, connecting to a mining pool.
  • Programming Bitcoin (in Ethereum we have a new and more powerful way to add logic to our transactions, the smart contracts) using BitcoinJS, sending transactions, writing an escrow contract
  • Alternative Coins

I like the mining descriptions, the attacks presentation and programming Bitcoin from JavaScript.

More resources in the next posts.

Stay tuned!

Angel “Java” Lopez


July 15, 2017

Blockchain: Links And Resources (45)

Filed under: Bitcoin, Blockchain, Ethereum, FinTech — ajlopez @ 5:13 pm

Previous Post 
Next Post

Mr. Blockchain Goes to Washington

The $3.8bn cryptocurrency bubble is a huge deal. But it could break the blockchain

Behind the scenes with Tezos, a new blockchain upstart

What is Blockchain Technology? A Step-by-Step Guide For Beginners

What happened to ethereum?

What is the next Ethereum?

Will Ethereum crash?

Exploring Continuous Token Models: Towards a Million Networks of Value.

Accenture, Microsoft team up on blockchain-based digital ID network

How cryptocurrency ethereum looks set to overtake bitcoin — in one chart

Visualizing Where Major US Banks Have Invested in Fintech

My Links

Stay tuned!

Angel “Java” Lopez

July 5, 2017

New Storage in Ethereum/RSK (1)

Filed under: Blockchain, Ethereum, RSK, Smart Contracts, Uncategorized — ajlopez @ 12:13 pm

An Ethereum Virtual Machine manages a contract storage, in cells, each one having a 32-byte address and a 32-byte value. A simplified view:

But in RSK implementation, there is a new feature: a cell can contain an arbitrary byte array data:

This feature is exposed by new methods included into the original Repository interface:

     * Put a value in storage of an account at a given key
     * @param addr of the account
     * @param key of the data to store
     * @param value is the data to store
    void addStorageRow(byte[] addr, DataWord key, DataWord value);

    void addStorageBytes(byte[] addr, DataWord key, byte[] value);

     * Retrieve storage value from an account for a given key
     * @param addr of the account
     * @param key associated with this value
     * @return data in the form of a <code>DataWord</code>
    DataWord getStorageValue(byte[] addr, DataWord key);

    byte[] getStorageBytes(byte[] addr, DataWord key);

The new methods are addStorageBytes and getStorageBytes. It was relatively easy to add, because the internal structure that represents the storage (a trie) is already prepared to store arbitrary data.

RSK implementation is using this features from precompiled contracts, and it is not available from EVM contracts.

In this post series, I want to describe new features that could be added to RSK storage, now it has byte array support.

Stay tuned!

Angel “Java” Lopez


July 2, 2017

Multi-Blockchains In Ethereum/RSK (2)

Filed under: Blockchain, Ethereum, RSK — ajlopez @ 7:26 pm

Previous Post

In order to support many blockchains in an Ethereum/RSK network, I propose two have “bi-colored” blocks:

A normal transaction have a sender account, a receiver account, an amount, contract data, and final state root. Now, a transaction could participate IN TWO “colored” blockchains: each account has an associated blockchain, and you can transfer from one account/blockchain to another account/blockchain.

To keep consensus, a “bi-colored” transaction has TWO final state roots: one for each blockchain.

A “bi-colored” block has TWO parents, one for each blockchain:

Not every node in the network knows ALL the blockchain states. But a node having the state of the “blue” blockchain can execute each transaction with a “blue” part, and check the final state root after applying the partial transaction to its own partial “blue” world state of the network. That is the interesting part: not all the nodes have to keep the FULL state of the network. It is enough to have many nodes, each controlling one or two colors.

Only the miner node that generated the “bi-colored” block should know the TWO world states, to generate the appropiate world state roots.

An account has a balance in EACH blockchain. But when a user creates an account, its address and use is available in any of the participant networks. So, it is a user decision what amount of balance their accounts have.

There is a difference with contracts: a contract is created in only one blockchain, and its storage is kept in that blockchain.

More details in the next post

Stay tuned!

Angel “Java” Lopez


June 25, 2017

Offchain Transactions In Ethereum/RSK (2)

Filed under: Blockchain, Ethereum, RSK, Uncategorized — ajlopez @ 4:25 pm

Previous Post

Each contract in Ethereum/RSK has an associated storage. This storage has addresses and content. The addresses are 32-bytes values, and the content is 32-bytes values (notably, RSK has support for storing arbitrary byte arrays in an storage cell, topic for another post). Then, an onchain storage looks like:

(simplified addresses and contents). Each missing address has a default value (zero in Ethereum for numeric storage cells). When the contract is running OFFCHAIN, the storage state is kept in the designated running node, not shared with the rest of the network. The offchain storage state is only known by the running node, and it can be altered sending offchain transactions to the contract, and invoking offchain calls to the contract/running node.

An offchain contract have code (written by the contract programmer) that commits the contract. If the commit operation is invoked (an special new opcode in Ethereum Virtual Machine, to be mapped by a modified solidity compiler, or using the assembly keyword in a solidity program), then the contract emits an onchain transaction, the so called delta transaction. Is a transaction that when mined and added to the winning blockchain, alters the onchain storage to the current offline storage state:

Some details to decide: the cost of such transactions, who pays the cost (my first guess: the sender of the invoke that raise the commit in the contract method code).

The delta transaction start to have more sense if its size is shorter than the size of all the offchain transaction that were processed by the running node, when the contract was in offchain state. Maybe, it could be the case for token contracts, where the state is usually the token balance by account, independently of the number of token transfer that were executed.

Although these ideas could be difficult to implement in the existing Ethereum implementations, RSK is a new implementation still under development, and then, this proposal could be implemented without disrupt existing behavior.

Next post topics: the offline transfer of value, cost of offchain transactions.

Stay tuned!

Angel “Java” Lopez



June 24, 2017

Alternative Proposal for Remasc Contract in Ethereum/RSK

Filed under: Blockchain, Ethereum, RSK, Uncategorized — ajlopez @ 5:37 pm

Since the release of public RSK testnet, the source code was published. And now, I can write about implementation details.

Ethereum platform supports the concept of precompiled contracts: contracts that are already implemented in the node code. In the case of RSK, we have two additional precompiled contracts: the Bridge contract, and the Remasc contract. In this post, I will propose an alternative implementation for Remasc contract (not yet with source code, there is no published official description for Remasc contract).

What is Remasc contract? AFAIK (remember, there is no public description yet), it is a contract that assign rewards to miners, examining the recent blockchain story. In order to calculate and assign rewards, it should have state related to the past blocks in the blockchain. This is the current state class. Also, there is a special Remasc transaction ADDED to EACH mined block, at the end of the list of transactions. And the target account is the Remasc contract. So, at the end of execution, that transaction is executed.

According to Ethereum Yellow Paper, there is a block finalization step:

11. Block Finalisation
The process of finalising a block involves four stages:
(1) Validate (or, if mining, determine) ommers;
(2) validate (or, if mining, determine) transactions;
(3) apply rewards;
(4) verify (or, if mining, compute a valid) state and nonce.

So, my first proposal is to remove the “compulsive added” transaction, and use the block finalization to invoke the contract. In this way, I could get rid off the nonce calculation, signing of transaction, block validation (a block SHOULD have that transaction), transaction serialization, transaction receipt storage, block transactions storage, etc….  To me, it is clear that having the reward process in the block finalization step instead of into an explicit transaction, is a simpler way. And you know, simplicity pays 🙂

The other proposal, to be explored, is to simplify the use of storage. The calculation of the next state could be performed with the blockchain information, already available. So, the current storage use is only a performance hack, that could be replaced, if needed, by an in-memory cache, removing the use of public blockchain storage. Ethereum storage is costly, and RSK is not an exception: in the current implementation, after more than 100000 blocks in testnet, running a local node in my machine, the Remasc storage takes 1/3 (one third) of total local storage. The Remasc should be deterministic, as any other contract. If for some reason it needs storage (to be reviewed when the specification is published)t, my first guess is that it needs less space than current implementation.

Stay tuned!

Angel “Java” Lopez


June 20, 2017

Offchain Transactions in Ethereum/RSK (1)

Filed under: Blockchain, Ethereum, RSK — ajlopez @ 4:45 pm

Next Post

In Ethereum/RSK, a contract has a lifecycle like:

A contract is an account, it has an address and balance like any other account. But additionally, it has code and storage. The transactions it received, can have value and invocation data. And each transaction has a cost, as it is saved in the blockchain.

In this post series, I will describe a possible implementation of support for offchain transactions and state. The idea is that a contract could be in another states, others than normal one:

When a contract is at offline state, it is executed in a designated running node, only ONE node, not in EVERY node of the network. The transactions it receives are execute only in the RUNNING NODE, and they are not added to the blockchain. So, the cost of the transactions could be free or near to free. Only when the contract decided to commit the new storage state, the state is published in the blockchain using a delta onchain transaction.

The change of state from normal to offchain is triggered by the contract itself. In its code, there is a new instruction (translated to new Ethereum VM opcode), to switch to offchain status. Then, all onchain transaction are rejected for this contract, no miner could add those transactions. But new offchain transactions should be routed to the running node (the only node that is running the offchain contract instance). An offchain transaction could be identified, ie, by a nonce of -1 (it is an implementation detail: the users can send onchain and offchain transactions: the former are processed only when the target contract is in normal state; the later only when it is in offchain state),

Again, the contract code could decide, when being in offchain state, to commit its state to the blockchain, or to rollback to the previous published state. If it decides to commit, then it switch to a temporary frozen state, until a delta onchain transaction is mined and accepted by the rest of the network. The delta transaction has the mission to update the published state to the new one, hosted by the running node.

In the next posts, I will describe the delta transaction with more detail, and I will discuss also the value transfer in case of offchain transactions. Maybe, now the RSK main code is public, I would publish a light implementation of these ideas.

Stay tuned!

Angel “Java” Lopez

June 18, 2017

Multi-Blockchains in Ethereum/RSK (1)

Filed under: Blockchain, Ethereum, RSK, Uncategorized — ajlopez @ 1:51 pm

Next Post

The implementation of a blockchain includes the creation, distribution, and manage of blocks:

A block, in Bitcoin and Ethereum, has:

  • An unique hash
  • A parent block, identified by hash
  • A block number (one plus parent block number)
  • A list of transactions

In the case of Ethereum and RSK, a transaction has:

  • A sender account
  • A receiver account
  • A value to transfer
  • Additional data (used if the receiver account is a smart contract)

A list of chained valid blocks form a blockchain:

In Ethereum/RSK, a block has also:

  • Uncle blocks
  • Associated Block Difficulty (difficulty of proof of work plus the sum of uncles difficulties)

So, the presence of uncles contributes to the block difficulty. And this number adds to the TOTAL difficulty of the blockchain. Many nodes in the network, called miners, could generate blocks to be added to the current blockchain, but the consensus algorithm  choose the blockchain with the greater total difficulty:

(in Bitcoin, the longest blockchain wins; in Ethereum/RSK a shorter blockchain could win if it has greater total cummulative associated difficulty).

One problem is to keep the state of all accounts and contracts in the system. Each transaction also has

  • State Root Hash

the hash of the world state AFTER the execution of the transaction. This hash is verified by every node in the network, so all the working nodes agrees on the resulting world state. A world state is saved in a trie, that can be identified by such root hash (see my previous work on tries Building a Blockchain (5) Building a Blockchain (12))

The block itself also has a State Root Hash, representing the world state AFTER the execution of the block. It could be different than the last transaction state root hash: the execution of block could assign rewards and alter account balances, if the protocol specifies the changes. This block root is also checked by the running nodes in the network, in order to validate the block state and consensus.

One problem is that the build of a block could be a bottlenect if the system should process many transactions (maybe hunders or thousands per second). This is the principal use case that guides the proposal of this post series. It could be interesting to have MANY blockchains:

Then, one blockchain could be dedicated to the process of a popular token/contract, or other blockchain could be dedicated to the transfer in a particular country. Only in few cases could be needed a transfer between blockchains. And this schema is not limited to TWO blockchains, we could have many blockchains. And the state storage and status could be maintaned by MANY nodes, sometimes, a node is dedicated to keep only ONE or TWO blockchains. So the scale of the operation does not hurt the system.

In the next post, I will describe the modification to apply to Ethereum/RSK so we can  manage multiple blockchains in the network.

Stay tuned!

Angel “Java” Lopez

Older Posts »

Blog at