def register_resources(self, args: Namespace) -> None:
from hathor.conf import HathorSettings
from hathor.p2p.resources import AddPeersResource, MiningInfoResource, MiningResource, StatusResource
from hathor.prometheus import PrometheusMetricsExporter
from hathor.resources import ProfilerResource
from hathor.transaction.resources import (
DashboardTransactionResource,
DecodeTxResource,
GraphvizLegacyResource,
GraphvizFullResource,
GraphvizNeighboursResource,
PushTxResource,
TipsHistogramResource,
TipsResource,
TransactionAccWeightResource,
TransactionResource,
)
from hathor.version_resource import VersionResource
from hathor.wallet.resources import (
AddressResource,
BalanceResource,
HistoryResource,
LockWalletResource,
SendTokensResource,
SignTxResource,
StateWalletResource,
UnlockWalletResource,
)
from hathor.wallet.resources.thin_wallet import (
AddressHistoryResource, SendTokensResource as
SendTokensThinResource, TokenHistoryResource, TokenResource)
from hathor.wallet.resources.nano_contracts import (
NanoContractDecodeResource,
NanoContractExecuteResource,
NanoContractMatchValueResource,
)
from hathor.websocket import HathorAdminWebsocketFactory, WebsocketStatsResource
from hathor.stratum.resources import MiningStatsResource
settings = HathorSettings()
if args.prometheus:
kwargs: Dict[str, Any] = {'metrics': self.manager.metrics}
if args.data:
kwargs['path'] = os.path.join(args.data, 'prometheus')
else:
raise ValueError(
'To run prometheus exporter you must have a data path')
prometheus = PrometheusMetricsExporter(**kwargs)
prometheus.start()
if args.status:
# TODO get this from a file. How should we do with the factory?
root = Resource()
wallet_resource = Resource()
root.putChild(b'wallet', wallet_resource)
thin_wallet_resource = Resource()
root.putChild(b'thin_wallet', thin_wallet_resource)
contracts_resource = Resource()
wallet_resource.putChild(b'nano-contract', contracts_resource)
p2p_resource = Resource()
root.putChild(b'p2p', p2p_resource)
graphviz = GraphvizLegacyResource(self.manager)
# XXX: reach the resource through /graphviz/ too, previously it was a leaf so this wasn't a problem
graphviz.putChild(b'', graphviz)
for fmt in ['dot', 'pdf', 'png', 'jpg']:
bfmt = fmt.encode('ascii')
graphviz.putChild(
b'full.' + bfmt,
GraphvizFullResource(self.manager, format=fmt))
graphviz.putChild(
b'neighbours.' + bfmt,
GraphvizNeighboursResource(self.manager, format=fmt))
resources = (
(b'status', StatusResource(self.manager), root),
(b'version', VersionResource(self.manager), root),
(b'mining', MiningResource(self.manager), root),
(b'getmininginfo', MiningInfoResource(self.manager), root),
(b'decode_tx', DecodeTxResource(self.manager), root),
(b'push_tx', PushTxResource(self.manager), root),
(b'graphviz', graphviz, root),
(b'tips-histogram', TipsHistogramResource(self.manager), root),
(b'tips', TipsResource(self.manager), root),
(b'transaction', TransactionResource(self.manager), root),
(b'transaction_acc_weight',
TransactionAccWeightResource(self.manager), root),
(b'dashboard_tx', DashboardTransactionResource(self.manager),
root),
(b'profiler', ProfilerResource(self.manager), root),
# /thin_wallet
(b'address_history', AddressHistoryResource(self.manager),
thin_wallet_resource),
(b'send_tokens', SendTokensThinResource(self.manager),
thin_wallet_resource),
(b'token', TokenResource(self.manager), thin_wallet_resource),
(b'token_history', TokenHistoryResource(self.manager),
thin_wallet_resource),
# /wallet/nano-contract
(b'match-value', NanoContractMatchValueResource(self.manager),
contracts_resource),
(b'decode', NanoContractDecodeResource(self.manager),
contracts_resource),
(b'execute', NanoContractExecuteResource(self.manager),
contracts_resource),
# /p2p
(b'peers', AddPeersResource(self.manager), p2p_resource),
)
for url_path, resource, parent in resources:
parent.putChild(url_path, resource)
if self.manager.stratum_factory is not None:
root.putChild(b'miners', MiningStatsResource(self.manager))
if self.wallet and args.wallet_enable_api:
wallet_resources = (
# /wallet
(b'balance', BalanceResource(self.manager), wallet_resource
),
(b'history', HistoryResource(self.manager),
wallet_resource),
(b'address', AddressResource(self.manager),
wallet_resource),
(b'send_tokens', SendTokensResource(self.manager),
wallet_resource),
(b'sign_tx', SignTxResource(self.manager),
wallet_resource),
(b'unlock', UnlockWalletResource(self.manager),
wallet_resource),
(b'lock', LockWalletResource(self.manager),
wallet_resource),
(b'state', StateWalletResource(self.manager),
wallet_resource),
)
for url_path, resource, parent in wallet_resources:
parent.putChild(url_path, resource)
# Websocket resource
ws_factory = HathorAdminWebsocketFactory(
metrics=self.manager.metrics,
wallet_index=self.manager.tx_storage.wallet_index)
ws_factory.start()
resource = WebSocketResource(ws_factory)
root.putChild(b"ws", resource)
ws_factory.subscribe(self.manager.pubsub)
# Websocket stats resource
root.putChild(b'websocket_stats',
WebsocketStatsResource(ws_factory))
real_root = Resource()
real_root.putChild(settings.API_VERSION_PREFIX.encode('ascii'),
root)
status_server = server.Site(real_root)
reactor.listenTCP(args.status, status_server)
# Set websocket factory in metrics
self.manager.metrics.websocket_factory = ws_factory
def test_token_history(self):
self.manager.wallet.unlock(b'MYPASS')
resource = StubSite(TokenHistoryResource(self.manager))
add_new_blocks(self.manager, 1, advance_clock=1)
add_blocks_unlock_reward(self.manager)
tx = create_tokens(self.manager,
mint_amount=100,
token_name='Teste',
token_symbol='TST')
token_uid = tx.tokens[0]
response = yield resource.get('thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 3
})
data = response.json_value()
# Success returning the token creation tx
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(1, len(data['transactions']))
self.assertEqual(tx.hash.hex(), data['transactions'][0]['tx_id'])
response = yield resource.get('thin_wallet/token_history', {
b'id': b'123',
b'count': 3
})
data = response.json_value()
# Fail because token is unknown
self.assertFalse(data['success'])
# Create a tx with this token, so we can have more tx in the history
output = tx.outputs[0]
script_type_out = parse_address_script(output.script)
address = script_type_out.address
private_key = self.manager.wallet.get_private_key(address)
output_address = decode_address(self.get_address(0))
o = TxOutput(100, create_output_script(output_address, None), 1)
i = TxInput(tx.hash, 0, b'')
tx2 = Transaction(inputs=[i], outputs=[o], tokens=[token_uid])
data_to_sign = tx2.get_sighash_all()
public_key_bytes, signature_bytes = self.manager.wallet.get_input_aux_data(
data_to_sign, private_key)
i.data = P2PKH.create_input_data(public_key_bytes, signature_bytes)
tx2.inputs = [i]
tx2.timestamp = int(self.clock.seconds())
tx2.weight = self.manager.minimum_tx_weight(tx2)
tx2.parents = self.manager.get_new_tx_parents()
tx2.resolve()
self.manager.propagate_tx(tx2)
# Now we have 2 txs with this token
response = yield resource.get('thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 3
})
data = response.json_value()
# Success returning the token creation tx and newly created tx
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(2, len(data['transactions']))
self.assertEqual(tx2.hash.hex(), data['transactions'][0]['tx_id'])
self.assertEqual(tx.hash.hex(), data['transactions'][1]['tx_id'])
response = yield resource.get('thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 1
})
data = response.json_value()
# Testing has_more
self.assertTrue(data['success'])
self.assertTrue(data['has_more'])
self.assertEqual(1, len(data['transactions']))
response = yield resource.get(
'thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 10,
b'page': b'next',
b'hash': tx2.hash.hex().encode(),
b'timestamp': str(tx2.timestamp).encode(),
})
data = response.json_value()
# Testing next
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(1, len(data['transactions']))
self.assertEqual(tx.hash.hex(), data['transactions'][0]['tx_id'])
response = yield resource.get(
'thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 10,
b'page': b'previous',
b'hash': tx.hash.hex().encode(),
b'timestamp': str(tx.timestamp).encode(),
})
data = response.json_value()
# Testing previous
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(1, len(data['transactions']))
self.assertEqual(tx2.hash.hex(), data['transactions'][0]['tx_id'])
response = yield resource.get(
'thin_wallet/token_history', {
b'id': token_uid.hex().encode(),
b'count': 10,
b'page': b'previous',
b'hash': tx2.hash.hex().encode(),
b'timestamp': str(tx2.timestamp).encode(),
})
data = response.json_value()
# Testing previous from first
self.assertTrue(data['success'])
self.assertFalse(data['has_more'])
self.assertEqual(0, len(data['transactions']))
def register_resources(self, args: Namespace) -> None:
from hathor.conf import HathorSettings
from hathor.debug_resources import (
DebugCrashResource,
DebugLogResource,
DebugMessAroundResource,
DebugPrintResource,
DebugRaiseResource,
DebugRejectResource,
)
from hathor.mining.ws import MiningWebsocketFactory
from hathor.p2p.resources import AddPeersResource, MiningInfoResource, MiningResource, StatusResource
from hathor.profiler import get_cpu_profiler
from hathor.profiler.resources import CPUProfilerResource, ProfilerResource
from hathor.prometheus import PrometheusMetricsExporter
from hathor.transaction.resources import (
BlockAtHeightResource,
CreateTxResource,
DashboardTransactionResource,
DecodeTxResource,
GetBlockTemplateResource,
GraphvizFullResource,
GraphvizNeighboursResource,
MempoolResource,
PushTxResource,
SubmitBlockResource,
TransactionAccWeightResource,
TransactionResource,
TxParentsResource,
ValidateAddressResource,
)
from hathor.version_resource import VersionResource
from hathor.wallet.resources import (
AddressResource,
BalanceResource,
HistoryResource,
LockWalletResource,
SendTokensResource,
SignTxResource,
StateWalletResource,
UnlockWalletResource,
)
from hathor.wallet.resources.nano_contracts import (
NanoContractDecodeResource,
NanoContractExecuteResource,
NanoContractMatchValueResource,
)
from hathor.wallet.resources.thin_wallet import (
AddressBalanceResource,
AddressHistoryResource,
AddressSearchResource,
SendTokensResource as SendTokensThinResource,
TokenHistoryResource,
TokenResource,
)
from hathor.websocket import HathorAdminWebsocketFactory, WebsocketStatsResource
settings = HathorSettings()
cpu = get_cpu_profiler()
if args.prometheus:
kwargs: Dict[str, Any] = {'metrics': self.manager.metrics}
if args.data:
kwargs['path'] = os.path.join(args.data, 'prometheus')
else:
raise ValueError('To run prometheus exporter you must have a data path')
prometheus = PrometheusMetricsExporter(**kwargs)
prometheus.start()
if args.status:
# TODO get this from a file. How should we do with the factory?
root = Resource()
wallet_resource = Resource()
root.putChild(b'wallet', wallet_resource)
thin_wallet_resource = Resource()
root.putChild(b'thin_wallet', thin_wallet_resource)
contracts_resource = Resource()
wallet_resource.putChild(b'nano-contract', contracts_resource)
p2p_resource = Resource()
root.putChild(b'p2p', p2p_resource)
graphviz = Resource()
# XXX: reach the resource through /graphviz/ too, previously it was a leaf so this wasn't a problem
graphviz.putChild(b'', graphviz)
for fmt in ['dot', 'pdf', 'png', 'jpg']:
bfmt = fmt.encode('ascii')
graphviz.putChild(b'full.' + bfmt, GraphvizFullResource(self.manager, format=fmt))
graphviz.putChild(b'neighbours.' + bfmt, GraphvizNeighboursResource(self.manager, format=fmt))
resources = [
(b'status', StatusResource(self.manager), root),
(b'version', VersionResource(self.manager), root),
(b'create_tx', CreateTxResource(self.manager), root),
(b'decode_tx', DecodeTxResource(self.manager), root),
(b'validate_address', ValidateAddressResource(self.manager), root),
(b'push_tx',
PushTxResource(self.manager, args.max_output_script_size, args.allow_non_standard_script),
root),
(b'graphviz', graphviz, root),
(b'transaction', TransactionResource(self.manager), root),
(b'block_at_height', BlockAtHeightResource(self.manager), root),
(b'transaction_acc_weight', TransactionAccWeightResource(self.manager), root),
(b'dashboard_tx', DashboardTransactionResource(self.manager), root),
(b'profiler', ProfilerResource(self.manager), root),
(b'top', CPUProfilerResource(self.manager, cpu), root),
(b'mempool', MempoolResource(self.manager), root),
# mining
(b'mining', MiningResource(self.manager), root),
(b'getmininginfo', MiningInfoResource(self.manager), root),
(b'get_block_template', GetBlockTemplateResource(self.manager), root),
(b'submit_block', SubmitBlockResource(self.manager), root),
(b'tx_parents', TxParentsResource(self.manager), root),
# /thin_wallet
(b'address_history', AddressHistoryResource(self.manager), thin_wallet_resource),
(b'address_balance', AddressBalanceResource(self.manager), thin_wallet_resource),
(b'address_search', AddressSearchResource(self.manager), thin_wallet_resource),
(b'send_tokens', SendTokensThinResource(self.manager), thin_wallet_resource),
(b'token', TokenResource(self.manager), thin_wallet_resource),
(b'token_history', TokenHistoryResource(self.manager), thin_wallet_resource),
# /wallet/nano-contract
(b'match-value', NanoContractMatchValueResource(self.manager), contracts_resource),
(b'decode', NanoContractDecodeResource(self.manager), contracts_resource),
(b'execute', NanoContractExecuteResource(self.manager), contracts_resource),
# /p2p
(b'peers', AddPeersResource(self.manager), p2p_resource),
]
if args.enable_debug_api:
debug_resource = Resource()
root.putChild(b'_debug', debug_resource)
resources.extend([
(b'log', DebugLogResource(), debug_resource),
(b'raise', DebugRaiseResource(), debug_resource),
(b'reject', DebugRejectResource(), debug_resource),
(b'print', DebugPrintResource(), debug_resource),
])
if args.enable_crash_api:
crash_resource = Resource()
root.putChild(b'_crash', crash_resource)
resources.extend([
(b'exit', DebugCrashResource(), crash_resource),
(b'mess_around', DebugMessAroundResource(self.manager), crash_resource),
])
for url_path, resource, parent in resources:
parent.putChild(url_path, resource)
if self.manager.stratum_factory is not None:
from hathor.stratum.resources import MiningStatsResource
root.putChild(b'miners', MiningStatsResource(self.manager))
with_wallet_api = bool(self.wallet and args.wallet_enable_api)
if with_wallet_api:
wallet_resources = (
# /wallet
(b'balance', BalanceResource(self.manager), wallet_resource),
(b'history', HistoryResource(self.manager), wallet_resource),
(b'address', AddressResource(self.manager), wallet_resource),
(b'send_tokens', SendTokensResource(self.manager), wallet_resource),
(b'sign_tx', SignTxResource(self.manager), wallet_resource),
(b'unlock', UnlockWalletResource(self.manager), wallet_resource),
(b'lock', LockWalletResource(self.manager), wallet_resource),
(b'state', StateWalletResource(self.manager), wallet_resource),
)
for url_path, resource, parent in wallet_resources:
parent.putChild(url_path, resource)
# Websocket resource
assert self.manager.tx_storage.indexes is not None
ws_factory = HathorAdminWebsocketFactory(metrics=self.manager.metrics,
address_index=self.manager.tx_storage.indexes.addresses)
ws_factory.start()
root.putChild(b'ws', WebSocketResource(ws_factory))
# Mining websocket resource
mining_ws_factory = MiningWebsocketFactory(self.manager)
root.putChild(b'mining_ws', WebSocketResource(mining_ws_factory))
ws_factory.subscribe(self.manager.pubsub)
# Websocket stats resource
root.putChild(b'websocket_stats', WebsocketStatsResource(ws_factory))
real_root = Resource()
real_root.putChild(settings.API_VERSION_PREFIX.encode('ascii'), root)
from hathor.profiler.site import SiteProfiler
status_server = SiteProfiler(real_root)
reactor.listenTCP(args.status, status_server)
self.log.info('with status', listen=args.status, with_wallet_api=with_wallet_api)
# Set websocket factory in metrics
self.manager.metrics.websocket_factory = ws_factory
def test_token_history_invalid_params(self):
resource = StubSite(TokenHistoryResource(self.manager))
# invalid count
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count': b'a'
})
data = response.json_value()
self.assertFalse(data['success'])
# missing token uid
response = yield resource.get('thin_wallet/token_history',
{b'count': b'3'})
data = response.json_value()
self.assertFalse(data['success'])
# invalid token uid
response = yield resource.get('thin_wallet/token_history', {
b'id': b'000',
b'count': b'3'
})
data = response.json_value()
self.assertFalse(data['success'])
# missing timestamp
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count':
b'3',
b'hash':
b'0000b1448893eb7efdd3c71b97b74d934a4ecaaf8a6b52f6cb5b60fdaf21497b',
})
data = response.json_value()
self.assertFalse(data['success'])
# invalid timestamp
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count': b'3',
b'hash':
b'0000b1448893eb7efdd3c71b97b74d934a4ecaaf8a6b52f6cb5b60fdaf21497b',
b'timestamp': b'a'
})
data = response.json_value()
self.assertFalse(data['success'])
# invalid hash
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count': b'3',
b'timestamp': b'1578118186',
b'page': b'next',
b'hash': b'000',
})
data = response.json_value()
self.assertFalse(data['success'])
# invalid page
response = yield resource.get(
'thin_wallet/token_history', {
b'id':
b'000003a3b261e142d3dfd84970d3a50a93b5bc3a66a3b6ba973956148a3eb824',
b'count':
b'3',
b'timestamp':
b'1578118186',
b'page':
b'nextYY',
b'hash':
b'0000b1448893eb7efdd3c71b97b74d934a4ecaaf8a6b52f6cb5b60fdaf21497b',
})
data = response.json_value()
self.assertFalse(data['success'])