def _process_Market_MarketCreated(transactionHash, blockHash, args):
# /// Event emitted when a new market was created.
# event MarketCreated (bytes16 indexed marketId, uint32 marketSeq, address owner, string terms, string meta,
# address maker, uint256 providerSecurity, uint256 consumerSecurity, uint256 marketFee);
self.log.info(
'{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) - XBR market created with ID {market_id})',
event=hlcontract('XBRMarket.MarketCreated'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()),
market_id=hlid(uuid.UUID(bytes=args.marketId)))
market_id = uuid.UUID(bytes=args.marketId)
if args.terms:
h = multihash.decode(multihash.from_b58_string(args.terms))
if h.name != 'sha2-256':
self.log.warn(
'WARNING: XBRMarket.MarketCreated - terms "{terms}" is not an IPFS (sha2-256) b58-encoded multihash',
terms=hlval(args.terms))
if args.meta:
h = multihash.decode(multihash.from_b58_string(args.meta))
if h.name != 'sha2-256':
self.log.warn(
'WARNING: XBRMarket.MarketCreated - meta "{meta}" is not an IPFS (sha2-256) b58-encoded multihash',
meta=hlval(args.meta))
stored = False
with self._db.begin(write=True) as txn:
market = self._xbr.markets[txn, market_id]
if market:
self.log.warn('{contract}(tx_hash={tx_hash}) record already stored in database.',
contract=hlcontract('MarketCreated'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()))
else:
market = cfxdb.xbr.market.Market()
market.market = market_id
market.timestamp = np.datetime64(time_ns(), 'ns')
# FIXME
# market.created = args.created
market.seq = args.marketSeq
market.owner = bytes(HexBytes(args.owner))
market.terms = args.terms
market.meta = args.meta
market.maker = bytes(HexBytes(args.maker))
market.provider_security = args.providerSecurity
market.consumer_security = args.consumerSecurity
market.market_fee = args.marketFee
self._xbr.markets[txn, market_id] = market
stored = True
if stored:
self.log.info('new {contract}(market_id={market_id}) record stored database!',
contract=hlcontract('MarketCreated'),
market_id=hlid(market_id))
def _process_Market_ActorJoined(transactionHash, blockHash, args):
# Event emitted when a new actor joined a market.
# event ActorJoined (bytes16 indexed marketId, address actor, uint8 actorType, uint joined, uint256 security, string meta);
self.log.info(
'{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) - XBR market actor {actor} joined market {market_id})',
event=hlcontract('XBRMarket.ActorJoined'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()),
actor=hlid(args.actor),
market_id=hlid(uuid.UUID(bytes=args.marketId)))
market_id = uuid.UUID(bytes=args.marketId)
actor_adr = bytes(HexBytes(args.actor))
actor_type = int(args.actorType)
if args.meta:
h = multihash.decode(multihash.from_b58_string(args.meta))
if h.name != 'sha2-256':
self.log.warn(
'WARNING: XBRMarket.MarketCreated - meta "{meta}" is not an IPFS (sha2-256) b58-encoded multihash',
terms=hlval(args.meta))
stored = False
with self._db.begin(write=True) as txn:
actor = self._xbr.actors[txn, (market_id, actor_adr, actor_type)]
if actor:
self.log.warn('{contract}(tx_hash={tx_hash}) record already stored in database.',
contract=hlcontract('MarketCreated'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()))
else:
actor = cfxdb.xbr.actor.Actor()
actor.timestamp = np.datetime64(time_ns(), 'ns')
actor.market = market_id
actor.actor = actor_adr
actor.actor_type = actor_type
actor.joined = args.joined
actor.security = args.security
actor.meta = args.meta
self._xbr.actors[txn, (market_id, actor_adr, actor_type)] = actor
stored = True
if stored:
self.log.info(
'new {contract}(market_id={market_id}, actor_adr={actor_adr}, actor_type={actor_type}) record stored database!',
contract=hlcontract('ActorJoined'),
market_id=hlid(market_id),
actor_adr=hlid('0x' + binascii.b2a_hex(actor_adr).decode()),
actor_type=hlid(actor_type))
def _process_Network_MemberRegistered(transactionHash, blockHash, args):
# /// Event emitted when a new member joined the XBR Network.
# event MemberCreated (address indexed member, string eula, string profile, MemberLevel level);
self.log.info(
'{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) - XBR member created at address {address})',
event=hlcontract('XBRNetwork.MemberCreated'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()),
address=hlid(args.member))
member_adr = bytes(HexBytes(args.member))
if args.eula:
h = multihash.decode(multihash.from_b58_string(args.eula))
if h.name != 'sha2-256':
self.log.warn(
'WARNING: XBRNetwork.MemberCreated - eula "{eula}" is not an IPFS (sha2-256) b58-encoded multihash',
eula=hlval(args.eula))
if args.profile:
h = multihash.decode(multihash.from_b58_string(args.profile))
if h.name != 'sha2-256':
self.log.warn(
'WARNING: XBRNetwork.MemberCreated - profile "{profile}" is not an IPFS (sha2-256) b58-encoded multihash',
eula=hlval(args.profile))
stored = False
with self._db.begin(write=True) as txn:
member = self._xbr.members[txn, member_adr]
if member:
self.log.warn('{contract}(tx_hash={tx_hash}) record already stored in database.',
contract=hlcontract('TokenApproval'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()))
else:
member = cfxdb.xbr.member.Member()
member.address = member_adr
member.timestamp = np.datetime64(time_ns(), 'ns')
member.registered = args.registered
member.eula = args.eula
member.profile = args.profile
member.level = args.level
self._xbr.members[txn, member_adr] = member
stored = True
if stored:
self.log.info('new {contract}(member_adr={member_adr}) record stored database!',
contract=hlcontract('MemberCreated'),
member_adr=hlid('0x' + binascii.b2a_hex(member_adr).decode()))
def _process_Token_Approval(transactionHash, blockHash, args):
# event Approval(address indexed from, address indexed to, uint256 value);
self.log.info(
'{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) - {value} XBR token approved (on-chain) from owner {owner} to spender {spender})',
event=hlcontract('XBRToken.Approval'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()),
value=hlval(int(args.value / 10**18)),
owner=hlval(args.owner),
spender=hlval(args.spender))
stored = False
with self._db.begin(write=True) as txn:
transactionHash = bytes(transactionHash)
token_approval = self._xbr.token_approvals[txn, transactionHash]
if token_approval:
self.log.warn('{contract}(tx_hash={tx_hash}) record already stored in database.',
contract=hlcontract('TokenApproval'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()))
else:
token_approval = cfxdb.xbr.token.TokenApproval()
token_approval.tx_hash = transactionHash
token_approval.block_hash = bytes(blockHash)
token_approval.owner_address = bytes(HexBytes(args.owner))
token_approval.spender_address = bytes(HexBytes(args.spender))
token_approval.value = args.value
self._xbr.token_approvals[txn, transactionHash] = token_approval
stored = True
if stored:
self.log.info('new {contract}(tx_hash={tx_hash}) record stored database!',
contract=hlcontract('TokenApproval'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()))
def _process_Token_Transfer(transactionHash, blockHash, args):
# event Transfer(address indexed from, address indexed to, uint256 value);
self.log.info(
'{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) - {value} XBR token transferred (on-chain) from {_from} to {_to})',
event=hlcontract('XBRToken.Transfer'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()),
value=hlval(int(args.value / 10**18)),
_from=hlval(args['from']),
_to=hlval(args.to))
stored = False
with self._db.begin(write=True) as txn:
transactionHash = bytes(transactionHash)
token_transfer = self._xbr.token_transfers[txn, transactionHash]
if token_transfer:
self.log.warn('{contract}(tx_hash={tx_hash}) record already stored in database.',
contract=hlcontract('TokenTransfer'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()))
else:
token_transfer = cfxdb.xbr.token.TokenTransfer()
token_transfer.tx_hash = transactionHash
token_transfer.block_hash = bytes(blockHash)
token_transfer.from_address = bytes(HexBytes(args['from']))
token_transfer.to_address = bytes(HexBytes(args.to))
token_transfer.value = args.value
self._xbr.token_transfers[txn, transactionHash] = token_transfer
stored = True
if stored:
self.log.info('new {contract}(tx_hash={tx_hash}) record stored database!',
contract=hlcontract('TokenTransfer'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()))
def _process_Market_ConsentSet(transactionHash, blockHash, args):
# Event emitted when a consent is set
# emit ConsentSet(member, updated, marketId, delegate, delegateType,
# apiCatalog, consent, servicePrefix);
self.log.info('{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) ..',
event=hlcontract('XBRMarket.ConsentSet'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()))
catalog_oid = uuid.UUID(bytes=args.apiCatalog)
member = uuid.UUID(bytes=args.member)
delegate = args.delegate
delegate_type = args.delegateType
market_oid = uuid.UUID(bytes=args.marketId)
with self._db.begin(write=True) as txn:
consent = self._xbr.consents[txn, (catalog_oid, member, delegate, delegate_type, market_oid)]
consent.synced = True
def _process_Catalog_CatalogCreated(transactionHash, blockHash, args):
# Event emitted when a new API catalog is created
# emit CatalogCreated(catalogId, created, catalogSeq, owner, terms, meta);
self.log.info('{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) ..',
event=hlcontract('XBRCatalog.CatalogCreated'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()))
catalog_oid = uuid.UUID(bytes=args.catalogId)
owner = bytes(HexBytes(args.owner))
created = np.datetime64(time_ns(), 'ns')
with self._db.begin(write=True) as txn:
catalog = cfxdb.xbr.catalog.Catalog()
catalog.oid = catalog_oid
catalog.timestamp = created
catalog.seq = args.catalogSeq
catalog.owner = owner
catalog.terms = args.terms
catalog.meta = args.meta
self._xbr.catalogs[txn, catalog_oid] = catalog
deferToThread(self._download_ipfs_file, args.meta)
def _process_Channel_Opened(transactionHash, blockHash, args):
# Event emitted when a new XBR data market has opened.
# event Opened(XBRTypes.ChannelType ctype, bytes16 indexed marketId, bytes16 indexed channelId,
# address actor, address delegate, address marketmaker, address recipient,
# uint256 amount, bytes signature);
self.log.info('{event}: processing event (tx_hash={tx_hash}, block_hash={block_hash}) ..',
event=hlcontract('XBRChannel.Opened'),
tx_hash=hlid('0x' + binascii.b2a_hex(transactionHash).decode()),
block_hash=hlid('0x' + binascii.b2a_hex(blockHash).decode()))
channel_oid = uuid.UUID(bytes=args.channelId)
marketmaker_adr = bytes(HexBytes(args.marketmaker))
marketmaker_adr_str = web3.Web3.toChecksumAddress(marketmaker_adr)
# we only persist data for xbr markets operated by one of the market makers we run in this worker
if marketmaker_adr_str not in self._maker_adr2id or self._maker_adr2id[
marketmaker_adr_str] not in self._makers:
self.log.info(
'{event}: skipping channel (channel {channel_oid} in market with market maker address {marketmaker_adr} is in for any market in this markets worker)',
event=hlcontract('XBRChannel.Opened'),
channel_oid=hlid(channel_oid),
marketmaker_adr=hlid(marketmaker_adr_str))
return
# prepare new channel data
channel_type = int(args.ctype)
market_oid = uuid.UUID(bytes=args.marketId)
actor_adr = bytes(HexBytes(args.actor))
delegate_adr = bytes(HexBytes(args.delegate))
recipient_adr = bytes(HexBytes(args.recipient))
amount = int(args.amount)
# FIXME
# signature = bytes(HexBytes(args.signature))
# FIXME
# member_oid = uuid.UUID()
# get the market maker by address
maker = self._makers[self._maker_adr2id[marketmaker_adr_str]]
# the market maker specific embedded database and schema
db = maker.db
xbrmm = maker.schema
# depending on channel type, different database schema classes and tables are used
if channel_type == cfxdb.xbrmm.ChannelType.PAYMENT:
channel = cfxdb.xbrmm.PaymentChannel()
channels = xbrmm.payment_channels
channels_by_delegate = xbrmm.idx_payment_channel_by_delegate
balance = cfxdb.xbrmm.PaymentChannelBalance()
balances = xbrmm.payment_balances
elif channel_type == cfxdb.xbrmm.ChannelType.PAYING:
channel = cfxdb.xbrmm.PayingChannel()
channels = xbrmm.paying_channels
channels_by_delegate = xbrmm.idx_paying_channel_by_delegate
balance = cfxdb.xbrmm.PayingChannelBalance()
balances = xbrmm.paying_balances
else:
assert False, 'should not arrive here'
# fill in information for newly replicated channel
channel.market_oid = market_oid
# FIXME
# channel.member_oid = member_oid
channel.channel_oid = channel_oid
channel.timestamp = np.datetime64(time_ns(), 'ns')
# channel.open_at = None
# FIXME: should read that from even args after deployment of
# https://github.com/crossbario/xbr-protocol/pull/138
channel.seq = 1
channel.channel_type = channel_type
channel.marketmaker = marketmaker_adr
channel.actor = actor_adr
channel.delegate = delegate_adr
channel.recipient = recipient_adr
channel.amount = amount
# FIXME
channel.timeout = 0
channel.state = cfxdb.xbrmm.ChannelState.OPEN
# FIXME
# channel.open_sig = signature
# create an off-chain balance record for the channel with remaining == initial amount
balance.remaining = channel.amount
# FIXME: should read that from even args after deployment of
# https://github.com/crossbario/xbr-protocol/pull/138
balance.seq = 1
# now store the new channel and balance in the database
stored = False
cnt_channels_before = 0
cnt_channels_by_delegate_before = 0
cnt_channels_after = 0
cnt_channels_by_delegate_after = 0
with db.begin(write=True) as txn:
if channels[txn, channel_oid]:
self.log.warn('{event}: channel already stored in database [channel_oid={channel_oid}]',
event=hlcontract('XBRChannel.Opened'),
channel_oid=hlid(channel_oid))
else:
cnt_channels_before = channels.count(txn)
cnt_channels_by_delegate_before = channels_by_delegate.count(txn)
# store the channel along with the off-chain balance
channels[txn, channel_oid] = channel
balances[txn, channel_oid] = balance
stored = True
cnt_channels_after = channels.count(txn)
cnt_channels_by_delegate_after = channels_by_delegate.count(txn)
self.log.info(
'{event} DB result: stored={stored}, cnt_channels_before={cnt_channels_before}, cnt_channels_by_delegate_before={cnt_channels_by_delegate_before}, cnt_channels_after={cnt_channels_after}, cnt_channels_by_delegate_after={cnt_channels_by_delegate_after}',
event=hlcontract('XBRChannel.Opened'),
stored=hlval(stored),
cnt_channels_before=hlval(cnt_channels_before),
cnt_channels_by_delegate_before=hlval(cnt_channels_by_delegate_before),
cnt_channels_after=hlval(cnt_channels_after),
cnt_channels_by_delegate_after=hlval(cnt_channels_by_delegate_after))
if stored:
# FIXME: publish WAMP event
self.log.info(
'{event}: new channel stored in database [actor_adr={actor_adr}, channel_type={channel_type}, market_oid={market_oid}, member_oid={member_oid}, channel_oid={channel_oid}]',
event=hlcontract('XBRChannel.Opened'),
market_oid=hlid(market_oid),
# FIXME
member_oid=hlid(None),
channel_oid=hlid(channel_oid),
actor_adr=hlid('0x' + binascii.b2a_hex(actor_adr).decode()),
channel_type=hlid(channel_type))
