Coinweb computation system
The Coinweb computation system can be broken down into creation of blocks in shards, processing of blocks, and processing of transactions.
At a high level, computation in Coinweb consists of processing blocks. Blocks
are produced by the shuffler. The shuffler in turn gets information from
underlying L1 blockchains, such as Bitcoin or Ethereum, as well as information
(in the form of
Jump transactions) from other Coinweb shards.
The processing of blocks is broken down into Computations. Computations are similar to smart contracts, but:
They are extensions to the Coinweb protocol, meaning third parties are NOT free to include arbitrary computations.
They are not restricted by gas or resources.
They are provided a richer API to interact with the ClaimDB.
Instead of being called by transactions, they are executed after every block.
This way, computations are intended to extend the core of Coinweb, rather than specific dApps
The current Computations in Coinweb are as follows:
The computations in yellow are run in parallel and consist of:
- Computing statistics about a block.
- Computing block information.
- Computing wCWEB staking information.
The computations in red are parallel internally.
The computation block for staking will be moved into the smart contract layer in a future update.
After the yellow computations are run, a fixed number of steps are performed, where each step executes the Coinweb VM computation and the Tokenization Block computation.
In Coinweb, the execution of smart contracts is done in parallel, and the Coinweb architecture also supports multiple smart contract virtual machines running side-by-side with full interoperability between the smart contract VMs.
This is done by separating I/O operations (communicating, reading, and writing claims) as well as transactionality, from smart contract execution. I/O and smart contract execution are interleaved in defined steps.
In Coinweb, a smart contract is a function that takes as input a transaction, and either fails or returns a list of transactions. The smart contract does not do I/O directly but does so indirectly through the output transaction it produces.
Smart contracts are invoked using the
Call operation which identifies the
smart contract virtual machine type (currently only WebAssembly is supported),
dynamically loads the code to be executed, and executes the smart contract in
its own VM.
Smart contract execution overview
Transactions are arrays of Coinweb VM operations.
In Transactions (v0), the available operations are:
Data- Data passed alongside a chain of transactions. Commonly used as input for smart contracts.
Read- Database lookups
Block- Block transaction on condition.
Take- Remove from the database a claim owned by the transaction issuer, and add the claim to the transaction. If the claim doesn't exist the transaction fails.
Store- Store into the database a claim owned by the transaction issuer.
Call- Invokes a smart contract.
Conceptually a smart contract is a function that takes as input a slice of a transaction and produces as output either a set of new transactions or a failure.
From the point of view of smart contract executions there are two types of operations:
Call: specify which smart contract to call, and the number of arguments (slice) to use
Any other op: operations such as
Storewill become arguments to the invoked smart contract. Each of them has some special behavior, that gets executed before the smart contract is invoked; for example, ReadOp will read a claim. For each op on the inputs slice, the smart contract will be able to see the op and the result of the op execution.
Given a parent transaction, for each call op, a smart contract will be called, and the combined output of all these contracts will become the transaction's children.
The first example is a transaction with a call to a smart contract that takes 3 parameters. Two of the parameters are read as claims, and the 3rd parameter is inlined into the transaction. The transaction also includes a write (the write will be aborted if the smart contract fails).
Note that there is an operation that will not be present on any slice of a smart
The second example is a transaction with 4 smart contract calls, all of them succeeding, and producing 11 children.
Note that there will be parent transactions with no calls to smart contracts,
and transactions with operations that will not be present on any slice to a
smart contract. All operations, even those that are not input to smart
contracts, get executed; notice that the execution of an operation has side
effects that are useful by themselves (for example,
Take removes a claim from
the DB and increases the CWEB balance of the transaction,
Read could be used
to force the transaction to fail conditionally,
Store creates a new
transaction in the DB...etc).
Note that it is valid for a successful smart contract execution to produce 0 children.
Note that a transaction made up of 0 operations is considered valid (though not that useful).
If any operation or any contract execution fails, the whole parent transaction and its children are aborted (that's why it is called a transaction!).
The transaction also gets aborted if:
The child transaction carry more CWEB than the parent transaction.
- Otherwise, transactions would be allowed to create CWEB out of nowhere.
- The CWEB carried by a transaction is the CWEB inside executed
Takeplus the CWEB inside
Dataminus the CWEB inside
The CWEB difference between parent and child transactions is not enough to cover the network fees.
Child transactions contain (counting repetitions) some claim inside a
Datathat is neither issued by the called smart contract nor present on the parent transaction.
If there's no reason to abort it, the changes are committed and the child transactions will become "parent transaction" on the next execution iteration, producing their own new child transactions (or failing).
Once a child transaction becomes a parent transaction, it will be "detached" from its "siblings", meaning that if it gets aborted, it will not cascade to its children or its previous parent (which was already committed).
This means that individual transactions are transactional, but the overall execution and results of on-chain computation is NOT transactional! This property (or lack thereof) is unique to Coinweb and implies big tradeoffs:
- "Never-ending" contracts are possible.
- Custom transactional semantics become a possibility.
Cons: Correctness of smart contracts is more tricky.
In this example, we show two transactions being executed in a (parallel) step, and the second smart contract from the first transaction fails.
Things to note: The first (parent) transaction, including any external I/O
effects, such as
Store are aborted. Also all children of any smart
contract call from that transaction are aborted. This is shown in black.
The second transaction is unaffected by the failing smart contract in the first transaction.
In this example, both parent transactions are aborted when there is a
conflict in the child transactions. Everything in black is aborted because of
the conflict in the red boxes.
For simplicity, the claims are called
y. When both
simultaneously stored into
y, this causes a conflict and both transactions are
On the other hand, two simultaneous writes to
x would not cause transactions
to be aborted as both
Store operations update
x with the same value and thus
no conflict exists.
Creating an explicit conflict is a useful technique to enforce failure of otherwise unrelated transactions.
On each shard, the loop of "parent transaction creates children, then children become new parents" iterates forever, we call it the "execution loop".
On every block, we will execute a fixed number of "execution loop" iterations; After these iterations, the intermediate result is saved on disk/memory and resumed when the next block is found.
The number of iterations is determined by the constant