Server backend for indexed ETH IPLD objects
Go to file
2018-12-21 10:33:31 -06:00
cmd finish method polling with hash or address type argument values 2018-12-21 10:33:31 -06:00
db finishing porting omni watcher to work with light sync; split into full, light, 2018-11-30 13:33:48 -06:00
dockerfiles/rinkeby dockerfiles/rinkeby: added named volume for pg container 2018-11-03 13:49:23 -05:00
documentation begin work on: Add checked_headers column for methods that are polled so taht we don’t duplicate; Add batching of method polling so that we arent generating a rediculously large account address list before using it to poll methods (or persist the list in pg?); User passed ABI and other ways to get ABI; Add ability to collect []byte and hashes from events and use them in method polling same manner as addresses; Event filter addrs => only those event’s addresses/hashes are used for polling; Option to persist seen address/hash/bytes lists into pg; Only generate lists of addresses, []byte, or hashes if a method will use them later 2018-12-21 10:33:31 -06:00
environments Generic watcher that takes a contract address, grabs the contract abi and starting block number, creates custom event filters, and extracts and transforms event data into postgres. Can configure to look at only a subset of events through CLI flag. Building but needs testing. 2018-11-03 14:00:25 -05:00
examples reorganizing omni directory and beginning light watcher work 2018-11-29 20:33:21 -06:00
integration_test port over lightSync updates from maker repo 2018-11-29 20:33:21 -06:00
libraries/shared Edits to address PR issues; change license from apache to AGPL; and work 2018-11-15 12:32:52 -06:00
pkg fetch event logs in batches- all events for a contract address at a given block height are fetched together, different contract events still fetched separately 2018-12-21 10:33:31 -06:00
scripts Get transactions (#45) 2018-03-27 16:06:12 -05:00
test_config port over lightSync updates from maker repo 2018-11-29 20:33:21 -06:00
utils Edits to address PR issues; change license from apache to AGPL; and work 2018-11-15 12:32:52 -06:00
vendor remove accidental duplicate vendor lib that was imported by goland 2018-12-21 10:33:21 -06:00
.gitignore Handle events 2018-03-05 10:01:50 -06:00
.private_blockchain_password Add integration test 2017-10-24 15:36:50 -05:00
.travis.yml finish method polling with hash or address type argument values 2018-12-21 10:33:31 -06:00
Gopkg.lock remove accidental duplicate vendor lib that was imported by goland 2018-12-21 10:33:21 -06:00
Gopkg.toml vendor updates to work with go 1.11 and geth 1.8.18 2018-11-29 20:33:21 -06:00
LICENSE Edits to address PR issues; change license from apache to AGPL; and work 2018-11-15 12:32:52 -06:00
main.go Merge old private repo into vulcanize 2018-01-25 18:08:26 -06:00
Makefile adjust retriever to pull token holder addresses from Transfer and Approval events (iterating over Approvals might be redundant); edit Makefile to import new missing dependencies of go-ethereum/accounts/keystore, organizing mocks and adding event related mocks and filters 2018-11-03 13:49:23 -05:00
README.md finish method polling with hash or address type argument values 2018-12-21 10:33:31 -06:00

Vulcanize DB

Join the chat at https://gitter.im/vulcanizeio/VulcanizeDB

Build Status

About

Vulcanize DB is a set of tools that make it easier for developers to write application-specific indexes and caches for dapps built on Ethereum.

Dependencies

Project Setup

Using Vulcanize for the first time requires several steps be done in order to allow use of the software. The following instructions will offer a guide through the steps of the process:

  1. Fetching the project
  2. Installing dependencies
  3. Configuring shell environment
  4. Database setup
  5. Configuring synced Ethereum node integration
  6. Data syncing

Installation

In order to fetch the project codebase for local use or modification, install it to your GOPATH via:

go get github.com/vulcanize/vulcanizedb

Once fetched, dependencies can be installed via go get or (the preferred method) at specific versions via golang/dep, the prototype golang pakcage manager. Installation instructions are here.

In order to install packages with dep, ensure you are in the project directory now within your GOPATH (default location is ~/go/src/github.com/vulcanize/vulcanizedb/) and run:

dep ensure

After dep finishes, dependencies should be installed within your GOPATH at the versions specified in Gopkg.toml.

Lastly, ensure that GOPATH is defined in your shell. If necessary, GOPATH can be set in ~/.bashrc or ~/.bash_profile, depending upon your system. It can be additionally helpful to add $GOPATH/bin to your shell's $PATH.

Setting up the Database

  1. Install Postgres

  2. Create a superuser for yourself and make sure psql --list works without prompting for a password.

  3. Execute createdb vulcanize_public

  4. Execute cd $GOPATH/src/github.com/vulcanize/vulcanizedb

  5. Run the migrations: make migrate HOST_NAME=localhost NAME=vulcanize_public PORT=<postgres port, default 5432>

    • See below for configuring additional environments

In some cases (such as recent Ubuntu systems), it may be necessary to overcome failures of password authentication from localhost. To allow access on Ubuntu, set localhost connections via hostname, ipv4, and ipv6 from peer/md5 to trust in: /etc/postgresql/<version>/pg_hba.conf

(It should be noted that trusted auth should only be enabled on systems without sensitive data in them: development and local test databases.)

Configuring Ethereum Node Integration

  • To use a local Ethereum node, copy environments/public.toml.example to environments/public.toml and update the ipcPath and levelDbPath.

    • ipcPath should match the local node's IPC filepath:

      • For Geth:

        • The IPC file is called geth.ipc.
        • The geth IPC file path is printed to the console when you start geth.
        • The default location is:
          • Mac: <full home path>/Library/Ethereum
          • Linux: <full home path>/ethereum/geth.ipc
      • For Parity:

        • The IPC file is called jsonrpc.ipc.
        • The default location is:
          • Mac: <full home path>/Library/Application\ Support/io.parity.ethereum/
          • Linux: <full home path>/local/share/io.parity.ethereum/
    • levelDbPath should match Geth's chaindata directory path.

      • The geth LevelDB chaindata path is printed to the console when you start geth.
      • The default location is:
        • Mac: <full home path>/Library/Ethereum/geth/chaindata
        • Linux: <full home path>/ethereum/geth/chaindata
      • levelDbPath is irrelevant (and coldImport is currently unavailable) if only running parity.
  • See environments/infura.toml to configure commands to run against infura, if a local node is unavailable. (Support is currently experimental, at this time.)

Start syncing with postgres

Syncs VulcanizeDB with the configured Ethereum node.

  1. Start the node
    • If node state is not yet fully synced, Vulcanize will not be able to operate on the fetched data. You will need to wait for the initial sync to finish.
  2. Start the vulcanize_db sync or lightSync
    • Execute ./vulcanizedb sync --config <path to config.toml>
    • Or ./vulcanizedb lightSync --config <path to config.toml>
    • Or to sync from a specific block: ./vulcanizedb sync --config <config.toml> --starting-block-number <block-number>
    • Or ./vulcanizedb lightSync --config <config.toml> --starting-block-number <block-number>

Alternatively, sync from Geth's underlying LevelDB

Sync VulcanizeDB from the LevelDB underlying a Geth node.

  1. Assure node is not running, and that it has synced to the desired block height.
  2. Start vulcanize_db
    • ./vulcanizedb coldImport --config <config.toml>
  3. Optional flags:
    • --starting-block-number <block number>/-s <block number>: block number to start syncing from
    • --ending-block-number <block number>/-e <block number>: block number to sync to
    • --all/-a: sync all missing blocks

Running the Tests

In order to run the full test suite, a test database must be prepared. By default, the rests use a database named vulcanize_private. Create the database in Postgres, and run migrations on the new database in preparation for executing tests:

make migrate HOST_NAME=localhost NAME=vulcanize_private PORT=<postgres port, default 5432>

Ginkgo is declared as a dep package test execution. Linting and tests can be run together via a provided make task:

make test

Tests can be run directly via Ginkgo in the project's root directory:

ginkgo -r

Start full environment in docker by single command

Geth Rinkeby

make command description
rinkeby_env_up start geth, postgres and rolling migrations, after migrations done starting vulcanizedb container
rinkeby_env_deploy build and run vulcanizedb container in rinkeby environment
rinkeby_env_migrate build and run rinkeby env migrations
rinkeby_env_down stop and remove all rinkeby env containers

Success run of the VulcanizeDB container require full geth state sync, attach to geth console and check sync state:

$ docker exec -it rinkeby_vulcanizedb_geth geth --rinkeby attach
...
> eth.syncing
false

If you have full rinkeby chaindata you can move it to rinkeby_vulcanizedb_geth_data docker volume to skip long wait of sync.

omniWatcher and lightOmniWatcher

These commands require a pre-synced (full or light, respectively) vulcanizeDB (see above sections) To watch all events of a contract: - Execute ./vulcanizedb omniWatcher --config <path to config.toml> --contract-address <contract address> - Or ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> To watch contracts on a network other than mainnet, use the network flag: - Execute ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> --network <ropsten, kovan, or rinkeby> To watch events within a certain block range use the starting block and ending block flags: - Execute ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> --starting-block-number <#> --ending-block-number <#> To watch only specified events use the events flag: - Execute ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> --events <EventName1> --events <EventName2> To watch events and poll the specified methods with any addresses and hashes emitted by the watched events utilize the methods flag: - Execute ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> --methods <methodName1> --methods <methodName2> To watch specified events and poll the specified method with any addresses and hashes emiited by the watched events: - Execute ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> --events <EventName1> --events <EventName2> --methods <methodName> To watch all types of events of the contract but only persist the ones that emit one of the filtered-for argument values: - Execute ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> --event-args <arg1> --event-args <arg2> To watch all events of the contract but only poll the specified method with specified argument values (if they are emitted from the watched events): - Execute ./vulcanizedb lightOmniWatcher --config <path to config.toml> --contract-address <contract address> --methods <methodName> --method-args <arg1> --method-args <arg2>