Package: metanode
Installationpip3 install virtualenv virtualenv <name of env> . <name of env>/bin/activate pip3 install websocket-client requests secp256k1 ecdsa git clone github.com/litepresence/??? python3 graphene_metanode_server.pyAbstractGraphene 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.MotivationThis project is phase one of a Hummingbot.io "connector"
for Peerplays and other Graphene based Decentralized ExchangesMetanode presents an locally hosted API layer between the trader and Graphene
optimized to support multiple chains and currency pairs concurrentlyA personal node requires expertise and resourcesa long term connection to any node operator is improbabletrusting a 3rd party blochchain api node can be riskysome public api connenctions are faster than othersquerying a graphene chain directly is not user friendlyRationaleThe 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.SpecificationsMetanode was built on an FM3+ AMD 7700K machine w/ 16GB ram, 256GB SSD
but may support 3 markets on a raspberry pi 4it has been built in anticipation of launch of the SONS and DEX on Peerplays mainnet.The initital pairs there are:BTC:PPY
HIVE:PPY
HBG:PPYIt has also been tested extensively on Bitshares mainnet.   The framework should be compatible
with other graphene chains with minor revisions.graphene_metanode_server.pyMetanode 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 atwww.hummingbot.ioMetanode 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.2The metanode server can be launched:python3 graphene_metanode_server.pygraphene_metanode_server.py is the principle product of this package but other sub modules can be used in a stand alone manner.unit testsdbux (data base user experience) is a visualization tool used to ensure everything is configured correctly with the metanode server.with graphene_metanode_server.py running, open two additional terminal tabs and run:python3 unit_test_dbux.pypython3 unit_test_public.pygraphene_client.pyTo instantiate the metanode, executemetanode = GrapheneTrustlessClient(constants: GrapheneConstants)From there the following methods are provided:metanode.pairs-- Returns a dict of dicts of pairs keyed byBASE-QUOTEtrading pair with subdicts:ops,  last, book, history , opens, fillscare has been taken with this data to ensure its in an easy to use format
as well as some metadataname,  id,  invert_pair, invert_idmetanode.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, cancelsmetanode.timing-- Returns a list of dicts of timing items:ping, read, begin, blocktime, blocknum, and handshakemetanode.assets-- Returns a dict of dicts keyed by asset name.name, id, precision, supply, fees_asset, balancecritically, 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 blockchainmetanode.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 usermetanode.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 nameevery metanode.xyz 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 configurationgraphene_contants.pyGrapheneConstants 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()
print(constants.metanode.MAVENS)
print(constants.core.BASE58)
print(constants.signing.KILL_OR_FILL)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;PAIRS, NODES, ACCOUNTThese 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)graphene_rpc.pyThese 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:python3 graphene_rpc.pyThis module can be imported as:from graphene_rpc import GrapheneRemoteProcedureCall
from graphene_constants import GrapheneConstants
rpc = GrapheneRemoteProcedureCall(GrapheneConstants("peerplays"))
print(rpc.last)
print(rpc.book)
print(rpc.history)
etc...graphene_sql.pyThis 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(),
}
# ==========================================================================
print(sql.execute([dml]))

>>> [{"col1":0 "col2":1}, {"col1":3 "col2":4}]unit test is included for this module, to build a test database:python3 graphene_sql.pygraphene_signing.pyECDSA 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.graphene_auth.pygraphene_auth.py is a wrapper for graphene_signing.py which provides the user with the functionsprototype_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 graphene_signing.py and broadcast by graphene_rpc.pyunit_test_private.pythis is a unit test for graphene_auth.py   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.DiscussionThis 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 ShareholdersPBSA and litepresence.com are cooperating to bring Hummingbot's algorithmic traders to the Graphene blockchain decentralized exchange community.Copyrightsee LICENSE.txtSee Alsowww.litepresence.comwww.pbsa.infowww.github.com/squidKid-deluxe