Skip to main content

metanode = GrapheneTrustlessClient()

Project description


pip3 install virtualenv
virtualenv <name of env>
. <name of env>/bin/activate
pip3 install websocket-client requests secp256k1 ecdsa
git clone
cd Graphene-Metanode


Graphene Metanode is a locally hosted node for one account and several trading pairs, which uses minimal RAM resources. It provides the necessary user stream data and order book data for trading in a format one would expect from a centralized exchange API.


This project is phase one of a "connector" for Peerplays and other Graphene based Decentralized Exchanges

Metanode presents an locally hosted API layer between the trader and Graphene optimized to support multiple chains and currency pairs concurrently

  • A personal node requires expertise and resources
  • a long term connection to any node operator is improbable
  • trusting a 3rd party blochchain api node can be risky
  • some public api connenctions are faster than others
  • querying a graphene chain directly is not user friendly


The aim of metanode is to present stable API utilizing a minimalist sqlite database. It provides data for one account and multiple trading pairs formatted as you'd expect from centralized exchange. All data provided is statitisticly validated among all user provided nodes in the network The result is a user friendly api for decentralized exchange order book and user stream with collection procedures offering 99.9999% uptime.


Metanode was built on an FM3+ AMD 7700K machine w/ 16GB ram, 256GB SSD but may support 3 markets on a raspberry pi 4

it has been built in anticipation of launch of the SONS and DEX on Peerplays mainnet.

The initital pairs there are:


It has also been tested extensively on Bitshares mainnet. The framework should be compatible with other graphene chains with minor revisions.

Metanode server is based on sqlite, standard python library.

It is an API layer between Graphene chains and Hummingbot. Hummingbot is an independent open source python algorithmic trading platform, learn more at

Metanode is the process of collecting data from the public api network and curating in a statistically sound manner to produce reliable data feeds from an otherwise unreliable network.

To make this possible, Mavens are streaming windowed lists of json data. This data has been collected directly from public api nodes that the user whitelists as "mostly trustworthy". Over time, each node in the list the user has provided might become disconnected, stale, or otherwise currupted. Metanode ensure the data feed remains reliable client side. Concurrently, multiple python processes are regeneratively spawned to deal with the outside world. They collect data, put it into the maven feed, and ensure the length of the feed remains windowed to provide a brief glimpse into the past.

In a seperate process an oracle reads the windowed lists provided by the maven processes and its sorts through this data using traditional statistic methods; predominately "mode". What we learn is "what most reliable nodes are reporting". The oralce; the the statiscial mode is moved to the respective base table in the database. A REAL or INTEGER in the oracle tables may be a json TEXT as maven, eg.

maven.account.fees.cancel = "[0.2, 0.2, 0.2, 0.1]" ->
account.fees.cancel = 0.2

The metanode server can be launched:

python3 is the principle product of this package but other sub modules can be used in a stand alone manner.

unit tests

dbux (data base user experience) is a visualization tool used to ensure everything is configured correctly with the metanode server.

with running, open two additional terminal tabs and run:



To instantiate the metanode, execute

metanode = GrapheneTrustlessClient(constants: GrapheneConstants)

From there the following methods are provided:

  • metanode.pairs -- Returns a dict of dicts of pairs keyed by BASE-QUOTE trading pair with subdicts: ops, last, book, history , opens, fills care has been taken with this data to ensure its in an easy to use format as well as some metadata name, id, invert_pair, invert_id

  • metanode.whitelist -- Returns a dynamic list of node urls; tested and sorted by latency.

  • metanode.account -- Returns pertinent account data for trading; transaciton fees, whether the user is lifetime member, and order cancels performed by the account (these are not sorted by pair) name, id, fees_account, ltm, cancels

  • metanode.timing -- Returns a list of dicts of timing items: ping, read, begin, blocktime, blocknum, and handshake

  • metanode.assets -- Returns a dict of dicts keyed by asset name. name, id, precision, supply, fees_asset, balance critically, the asset precisison is cached here which allows for graphene integer based math to occur in the background. The user's account balances per asset are also here, in total, tied, and free terms.

  • metanode.chain -- returns dict with keys id and name; the chain id is the grahene identifier for the blockchain

  • metanode.nodes -- Returns a dict of dicts of nodes keyed by websocket url this list is used to provide connectivity information in for each note provided by the user

  • metanode.objects -- Returns a dict of dicts keyed by asset id objects provides cached reference between graphenes' a.b.c object id's and their respective object name

every method is a SQL database query and should be cached at time of use to dict(metanode_xyz) to avoid excess database lookups the format of each response is described in the docstrings below all of the data returned is as as a list or dict python object loaded from json and containing str/float/int values these responses are statistically clean "mode" or "median" as appropritate from all responding nodes the user has provided upon configuration

GrapheneConstants is a class that can be instantiated with or without a chain specified. Without, it gives access to all constants that are not chain specific, eg.

from graphene_constants import GrapheneConstants
constants = GrapheneConstants()

The above constants should be adjusted with caution. Some of the metanode constants involve a balancing act between your system resources and your latency. Effort has been made to provide sensible, system safe metanode constants.

The user only needs to ajust chain specific constants;


These are to be edited in file and saved. Default values are provided for simulation and testing.

When specifying the chain you gain access to the chain specific constants, eg.

constants = GrapheneConstants("peerplays")
print(constants.chain.NODES, constants.chain.PAIRS, constants.chain.ACCOUNT)

These are public api calls to nodes in the network. The responses are normalized to human terms from graphene integer math always at this level. The nested dictionaries are flattened, excess data is stripped. Prices are in float format with 16 digit precision. Amounts are in float format with the respective precision of each asset. The purpose is to refine what is most pertinent to algorithmic traders and put it in the format they would expect from a centralized exchange. A unit test is included for this module, to test the rpc methods:


This module can be imported as:

from graphene_rpc import GrapheneRemoteProcedureCall
from graphene_constants import GrapheneConstants
rpc = GrapheneRemoteProcedureCall(GrapheneConstants("peerplays"))
# etc...

This module sets up a new database for one chain, for one account, and for multiple trading pairs. It creates space for all pertinent data using multiple sqlite tables with rows columns containing json:

It also provides a safe read/write wrapper used by other modules formating the database rows and columns instead as a python a list of dicts.

dml = {
   "query": f"""
   SELECT * FROM {table}
   "values": tuple(),
# ==========================================================================

>>> [{"col1":0 "col2":1}, {"col1":3 "col2":4}]

unit test is included for this module, to build a test database:


ECDSA transaction signing is distilled from pybitshares(MIT), but is not dependent. serializing, signing, and verifying is all spelled out in script in a minimalist manner for the task. This consise script takes the place of the otherwise large python signing dependency. is a wrapper for which provides the user with the functions

prototype_order() broker(order)

prototype order creates the required headers for an order on the blockchain. broker method ensures the order is properly built and then sends it on to be signed by and broadcast by

this is a unit test for the user should familiarize themselves with the amounts and prices hard coded to be bought/sold. tests can be performed on testnet or mainnet of peerplays or bitshares.


This project is phase one of connecting Peerplays and other graphene blockchains to hummingbot. This package can be used stand alone, as sub modules, or eventually as part of a hummingbot market making connector.

Summary for Shareholders

PBSA and are cooperating to bring Hummingbot's algorithmic traders to the Graphene blockchain decentralized exchange community.


see LICENSE.txt

See Also

Tip Cup

(Bitshares) litepresence1 1.2.743179 (Bitshares) squidkid-deluxe256 1.2.1798534

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Source Distribution

metanode-1.0.4.tar.gz (63.5 kB view hashes)

Uploaded Source

Built Distribution

metanode-1.0.4-py3-none-any.whl (66.6 kB view hashes)

Uploaded Python 3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page