4651558b98
(the code is not cleaned up yet, especially DB related part)
1. Separate claim nodes from the Trie to NodeMgr (Node Manager).
The Trie is mainly responsible for rsolving the MerkleHash.
The Node Manager, which manages all the claim nodes implements
KeyValue interface.
type KeyValue interface{
Get(Key) error
Set(Key, Value) error
}
When the Trie traverses to the Value node, it consults the KV
with the prefix to get the value, which is the Hash of Best Claim.
2. Versioined/Snapshot based/Copy-on-Write Merkle Trie.
Every resolved trie node is saved to the TrieDB (leveldb) with it's
Hash as Key and content as Value.
The content has the following format:
Char (1B) Hash (32B) {0 to 256 entries }
VHash (32B) (0 or 1 entry)
The nodes are immutable and content(hash)-addressable. This gives
the benefit of de-dup for free.
3. The NodeManager implements Replay, and can construct any past state.
After experimentng on Memento vs Replay with the real dataset on the
mainnet. I decided to go with Replay (at least for now) for a few reasons:
a. Concurrency and usability.
In the real world scenario, the ClaimTrie is always working on the
Tip of the chain to accept Claim Script, update its own state and
generate the Hash.
On the other hand, most of the client requests are interested in
the past state with minimal number of confirmations required.
With Memento, the ClaimTrie has to either:
a. Pin down the node, and likely the ClaimTrie itself as well, as
it doesn't have the latest state (in terms of the whole Trie) to
resolve the Hash. Undo the changes and redo the changes after
serving the request.
b. Copy the current state of the node and rollback that node to
serve the request in the background.
With Replay, the ClaimTrie can simply spin a background task
without any pause.
The history of the nodes is immutable and read-only, so there is
contention in reconstructing a node.
b. Negligible performance difference.
Most of the nodes only have few commands to playback.
The time to playback is negligible, and will be dominated by the
I/O if the node was flushed to the disk.
c. Simplicity.
Implementing undo saves more changes of states during
the process, and has to pay much more attention to the bidding rules.
1.9 KiB
1.9 KiB
ClaimTrie
coming soon
Installation
coming soon
Usage
coming soon
Running from Source
This project requires Go v1.10 or higher.
go get -u -v github.com/lbryio/claimtrie
Examples
Refer to claimtrie for an interactive CLI tool.
NAME:
claimtrie - A CLI tool for LBRY ClaimTrie
USAGE:
main [global options] command [command options] [arguments...]
VERSION:
0.0.1
COMMANDS:
add-claim, ac Claim a name with specified amount. (outPoint is generated randomly, if unspecified)
add-support, as Add support to a specified Claim. (outPoint is generated randomly, if unspecified)
spend-claim, sc Spend a specified Claim.
spend-support, ss Spend a specified Support.
show, s Show the Key-Value pairs of the Stage or specified commit. (links nodes are showed if -a is also specified)
merkle, m Show the Merkle Hash of the Stage.
commit, c Commit the current Stage to commit database.
reset, r Reset the Stage to a specified commit.
log, l List the commits in the coommit database.
shell, sh Enter interactive mode
help, h Shows a list of commands or help for one command
GLOBAL OPTIONS:
--help, -h show help
--version, -v print the version
Testing
go test -v github.com/lbryio/claimtrie
gocov test -v github.com/lbryio/claimtrie 1>/dev/null
Contributing
coming soon
License
This project is MIT licensed.
Security
We take security seriously. Please contact security@lbry.io regarding any security issues. Our PGP key is here if you need it.
Contact
The primary contact for this project is @roylee17 (roylee@lbry.io)