def serialize_formatting_hook(self, obj_dict):

        if self.account:
            obj_dict['attributes']['account'] = self.account.serialize()

        if obj_dict['attributes'].get('address'):
            obj_dict['attributes']['address_id'] = obj_dict['attributes']['address'].replace('0x', '')
            obj_dict['attributes']['address'] = ss58_encode(obj_dict['attributes']['address'].replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)

        for item in obj_dict['attributes'].get('params', []):
            # SS58 format Addresses public keys
            if item['type'] in ['Address', 'AccountId'] and item['value']:
                self.format_address(item)
            elif item['type'] in ['Vec<Address>', 'Vec<AccountId>', 'Vec<<Lookup as StaticLookup>::Source>'] and item['value']:
                for idx, vec_item in enumerate(item['value']):
                    item['value'][idx] = {
                        'name': idx,
                        'type': 'Address',
                        'value': ss58_encode(vec_item.replace('0x', ''), SUBSTRATE_ADDRESS_TYPE),
                        'orig_value': vec_item.replace('0x', '')
                    }
            elif item['type'] == 'Box<Proposal>':
                for proposal_param in item['value'].get('call_args', []):
                    if proposal_param['type'] == 'Address':
                        self.format_address(proposal_param)

        return obj_dict
 def serialize_item(self, item):
     return {
         'type': 'balancetransfer',
         'id': '{}-{}'.format(item.block_id, item.event_idx),
         'attributes': {
             'block_id':
             item.block_id,
             'event_idx':
             '{}-{}'.format(item.block_id, item.event_idx),
             'sender':
             ss58_encode(item.attributes[0]['value'].replace('0x', ''),
                         SUBSTRATE_ADDRESS_TYPE),
             'sender_id':
             item.attributes[0]['value'].replace('0x', ''),
             'destination':
             ss58_encode(item.attributes[1]['value'].replace('0x', ''),
                         SUBSTRATE_ADDRESS_TYPE),
             'destination_id':
             item.attributes[1]['value'].replace('0x', ''),
             'value':
             item.attributes[2]['value'],
             'fee':
             item.attributes[3]['value']
         }
     }
Exemple #3
0
 def serialize_item(self, item):
     return {
         'type': 'balancetransfer',
         'id': item.extrinsic_hash,
         'attributes': {
             'block_id':
             item.block_id,
             'extrinsic_hash':
             item.extrinsic_hash,
             'extrinsic_idx':
             item.extrinsic_idx,
             'sender':
             ss58_encode(item.address, SUBSTRATE_ADDRESS_TYPE),
             'sender_id':
             item.address,
             'destination':
             ss58_encode(item.params[0]['value'], SUBSTRATE_ADDRESS_TYPE),
             'destination_id':
             item.params[0]['value'].replace('0x', ''),
             'value':
             item.params[1]['value'],
             'success':
             item.success,
             'error':
             item.error,
         }
     }
Exemple #4
0
    def serialize_formatting_hook(self, obj_dict):

        if self.validator_stash_account:
            obj_dict['attributes'][
                'validator_stash_account'] = self.validator_stash_account.serialize(
                )

        obj_dict['attributes']['validator_stash_id'] = self.validator_stash
        if self.validator_stash:
            obj_dict['attributes']['validator_stash'] = ss58_encode(
                self.validator_stash.replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)
        else:
            obj_dict['attributes']['validator_stash'] = None

        obj_dict['attributes'][
            'validator_controller_id'] = self.validator_controller

        if self.validator_controller:
            obj_dict['attributes']['validator_controller'] = ss58_encode(
                self.validator_controller.replace('0x', ''),
                SUBSTRATE_ADDRESS_TYPE)
        else:
            obj_dict['attributes']['validator_controller'] = None

        obj_dict['attributes']['validator_session_id'] = self.validator_session
        if self.validator_session:
            obj_dict['attributes']['validator_session'] = ss58_encode(
                self.validator_session.replace('0x', ''),
                SUBSTRATE_ADDRESS_TYPE)
        else:
            obj_dict['attributes']['validator_session'] = None

        return obj_dict
Exemple #5
0
    def serialize_formatting_hook(self, obj_dict):

        if self.nominator_stash_account:
            obj_dict['attributes'][
                'nominator_stash_account'] = self.nominator_stash_account.serialize(
                )
        else:
            obj_dict['attributes']['nominator_stash_account'] = {
                'type': 'account',
                'id': self.nominator_stash.replace('0x', ''),
                'attributes': {
                    'id':
                    self.nominator_stash.replace('0x', ''),
                    'address':
                    ss58_encode(self.nominator_stash.replace('0x', ''),
                                SUBSTRATE_ADDRESS_TYPE)
                }
            }

        if self.nominator_controller:
            obj_dict['attributes'][
                'nominator_controller_id'] = self.nominator_controller
            obj_dict['attributes']['nominator_controller'] = ss58_encode(
                self.nominator_controller.replace('0x', ''),
                SUBSTRATE_ADDRESS_TYPE)

        return obj_dict
    def serialize_formatting_hook(self, obj_dict):

        for item in obj_dict['attributes']['attributes']:
            if item['type'] in ['AccountId', 'AuthorityId', 'Address'
                                ] and item['value']:
                # SS58 format AccountId public keys
                item['orig_value'] = item['value'].replace('0x', '')
                item['value'] = ss58_encode(item['value'].replace('0x', ''),
                                            SUBSTRATE_ADDRESS_TYPE)

            elif item['type'] in ['AccountIndex'] and item['value']:
                # SS58 format Account index
                item['orig_value'] = item['value']
                item['value'] = ss58_encode_account_index(
                    item['value'], SUBSTRATE_ADDRESS_TYPE)
            elif item['type'] in ['AuthorityList'] and item['value']:
                for idx, vec_item in enumerate(item['value']):
                    item['value'][idx]['AuthorityId'] = {
                        'name':
                        'AuthorityId',
                        'type':
                        'Address',
                        'value':
                        ss58_encode(vec_item['AuthorityId'].replace('0x', ''),
                                    SUBSTRATE_ADDRESS_TYPE),
                        'orig_value':
                        vec_item['AuthorityId'].replace('0x', '')
                    }
            elif item['type'] == 'Vec<IdentificationTuple>':
                for idx, vec_item in enumerate(item['value']):
                    item['value'][idx]['validatorId'] = {
                        'name':
                        'validatorId',
                        'type':
                        'Address',
                        'value':
                        ss58_encode(vec_item['validatorId'].replace('0x', ''),
                                    SUBSTRATE_ADDRESS_TYPE),
                        'orig_value':
                        vec_item['validatorId'].replace('0x', '')
                    }

                    for other_idx, other_item in enumerate(
                            vec_item['exposure']['others']):
                        item['value'][idx]['exposure']['others'][other_idx][
                            'who'] = {
                                'name':
                                'validatorId',
                                'type':
                                'Address',
                                'value':
                                ss58_encode(
                                    other_item['who'].replace('0x', ''),
                                    SUBSTRATE_ADDRESS_TYPE),
                                'orig_value':
                                other_item['who'].replace('0x', '')
                            }

        return obj_dict
    def serialize_item(self, item):

        sender = Account.query(self.session).get(
            item.attributes[0]['value'].replace('0x', ''))

        if sender:
            sender_data = sender.serialize()
        else:
            sender_data = {
                'type': 'account',
                'id': item.attributes[0]['value'].replace('0x', ''),
                'attributes': {
                    'id':
                    item.attributes[0]['value'].replace('0x', ''),
                    'address':
                    ss58_encode(item.attributes[0]['value'].replace('0x', ''),
                                settings.SUBSTRATE_ADDRESS_TYPE)
                }
            }

        destination = Account.query(self.session).get(
            item.attributes[1]['value'].replace('0x', ''))

        if destination:
            destination_data = destination.serialize()
        else:
            destination_data = {
                'type': 'account',
                'id': item.attributes[1]['value'].replace('0x', ''),
                'attributes': {
                    'id':
                    item.attributes[1]['value'].replace('0x', ''),
                    'address':
                    ss58_encode(item.attributes[1]['value'].replace('0x', ''),
                                settings.SUBSTRATE_ADDRESS_TYPE)
                }
            }

        # Some networks don't have fees
        if len(item.attributes) == 4:
            fee = item.attributes[3]['value']
        else:
            fee = 0

        return {
            'type': 'balancetransfer',
            'id': '{}-{}'.format(item.block_id, item.event_idx),
            'attributes': {
                'block_id': item.block_id,
                'event_idx': '{}-{}'.format(item.block_id, item.event_idx),
                'sender': sender_data,
                'destination': destination_data,
                'value': item.attributes[2]['value'],
                'fee': fee
            }
        }
    def serialize_formatting_hook(self, obj_dict):
        obj_dict['attributes']['nominator_stash_id'] = self.nominator_stash
        obj_dict['attributes']['nominator_stash'] = ss58_encode(self.nominator_stash.replace('0x', ''),
                                                                SUBSTRATE_ADDRESS_TYPE)

        if self.nominator_controller:
            obj_dict['attributes']['nominator_controller_id'] = self.nominator_controller
            obj_dict['attributes']['nominator_controller'] = ss58_encode(self.nominator_controller.replace('0x', ''),
                                                                         SUBSTRATE_ADDRESS_TYPE)

        return obj_dict
    def serialize_formatting_hook(self, obj_dict):
        obj_dict['attributes']['proposed_by_address'] = ss58_encode(
            self.proposed_by_account_id.replace('0x', ''),
            SUBSTRATE_ADDRESS_TYPE
        )

        obj_dict['attributes']['beneficiary_address'] = ss58_encode(
            self.beneficiary_account_id.replace('0x', ''),
            SUBSTRATE_ADDRESS_TYPE
        )

        return obj_dict
Exemple #10
0
    def on_get(self, req, resp):
        resp.status = falcon.HTTP_200

        page = int(req.params.get('page') if req.params.get('page') else 1)
        pageSize = int(
            req.params.get('page_size') if req.params.get('page_size') else 10)
        extrinsics = Extrinsic.latest_extrinsics(self.session, page, pageSize)

        result = []
        for extrinsic in extrinsics:
            extrinsicId = '{}-{}'.format(extrinsic.block_id,
                                         extrinsic.extrinsic_idx)
            fromAddr = ss58_encode(extrinsic.address.replace('0x', ''))
            hash = "0x{}".format(extrinsic.extrinsic_hash)
            timestamp = extrinsic.datetime.strftime(
                "%Y-%m-%d %H:%M:%S"
            ) if extrinsic.datetime is not None else None
            blockId = extrinsic.block_id
            success = extrinsic.success
            # print(extrinsic);
            # timestamp = time.mktime(extrinsic.datetime.timetuple())

            params = json.loads(extrinsic.params)
            for param in params:
                name = param.get('name')
                if name == 'dest':
                    toAddr = ss58_encode(param.get('value').replace('0x', ''))
                elif name == 'value':
                    coin = param.get('value') / 1000000000000000  # 转换为单位 Unit

            result.append({
                "extrinsic_id": extrinsicId,
                "block_id": blockId,
                "from": fromAddr,
                "to": toAddr,
                "hash": hash,
                "timestamp": timestamp,
                "coin": coin,
                "result": success
            })

        count = Extrinsic.query(self.session).filter(
            and_(Extrinsic.module_id == "balances",
                 Extrinsic.call_id == "transfer")).count()
        resp.media = {
            'status': 'success',
            'data': {
                "result": result,
                "count": count
            }
        }
    def sequencing_hook(self, db_session, parent_block_data, parent_sequenced_block_data):

        for account_audit in AccountAudit.query(db_session).filter_by(block_id=self.block.id).order_by('event_idx'):
            try:
                account = Account.query(db_session).filter_by(id=account_audit.account_id).one()

                if account_audit.type_id == ACCOUNT_AUDIT_TYPE_REAPED:
                    account.count_reaped += 1
                    account.is_reaped = True

                elif account_audit.type_id == ACCOUNT_AUDIT_TYPE_NEW:
                    account.is_reaped = False

                account.updated_at_block = self.block.id

            except NoResultFound:

                account = Account(
                    id=account_audit.account_id,
                    address=ss58_encode(account_audit.account_id, SUBSTRATE_ADDRESS_TYPE),
                    created_at_block=self.block.id,
                    updated_at_block=self.block.id,
                    balance=0
                )

                # If reaped but does not exist, create new account for now
                if account_audit.type_id != ACCOUNT_AUDIT_TYPE_NEW:
                    account.is_reaped = True
                    account.count_reaped = 1

            account.save(db_session)
    def serialize_formatting_hook(self, obj_dict):

        if self.author:
            obj_dict['attributes']['author_id'] = self.author
            obj_dict['attributes']['author'] = ss58_encode(self.author.replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)

        return obj_dict
    def serialize_formatting_hook(self, obj_dict):
        obj_dict['attributes']['account_id'] = self.account_id
        if self.account_id:
            obj_dict['attributes']['address'] = ss58_encode(self.account_id.replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)
        else:
            obj_dict['attributes']['address'] = None

        return obj_dict
    def serialize_formatting_hook(self, obj_dict):

        if self.type_id == LOG_TYPE_AUTHORITIESCHANGE:

            for idx, item in enumerate(obj_dict['attributes']['data']['value']):
                obj_dict['attributes']['data']['value'][idx] = ss58_encode(item.replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)

        return obj_dict
Exemple #15
0
 def serialize_item(self, item):
     return {
         'type': 'transfer',
         'id': '{}-{}'.format(item.block_id, item.event_idx),
         'attributes': {
             'block_id': item.block_id,
             'event_idx': item.event_idx,
             'extrinsic_idx': item.extrinsic_idx,
             'from_account_id': item.from_account_id,
             'from_address': ss58_encode(item.from_account_id, SUBSTRATE_ADDRESS_TYPE),
             'to_account_id': item.to_account_id,
             'to_address': ss58_encode(item.to_account_id, SUBSTRATE_ADDRESS_TYPE),
             'balance': float(item.balance),
             'from_did': item.from_did,
             'to_did': item.to_did,
             'fee': float(item.fee),
             'datetime': item.datetime.isoformat()
         }
     }
    def serialize_formatting_hook(self, obj_dict):

        for item in obj_dict['attributes']['attributes']:
            if item['type'] in ['AccountId', 'AuthorityId', 'Address'] and item['value']:
                # SS58 format AccountId public keys
                item['orig_value'] = item['value'].replace('0x', '')
                item['value'] = ss58_encode(item['value'].replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)

            elif item['type'] in ['AccountIndex'] and item['value']:
                # SS58 format Account index
                item['orig_value'] = item['value']
                item['value'] = ss58_encode_account_index(item['value'], SUBSTRATE_ADDRESS_TYPE)

        return obj_dict
    def serialize_formatting_hook(self, obj_dict):

        if obj_dict['attributes'].get('address'):
            obj_dict['attributes']['address_id'] = obj_dict['attributes']['address'].replace('0x', '')
            obj_dict['attributes']['address'] = ss58_encode(obj_dict['attributes']['address'].replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)

        for item in obj_dict['attributes']['params']:

            # SS58 format Addresses public keys
            if item['type'] in ['Address', 'AccountId'] and item['value']:
                self.format_address(item)
            if item['type'] == 'Box<Proposal>':
                for proposal_param in item['value'].get('params', []):
                    if proposal_param['type'] == 'Address':
                        self.format_address(proposal_param)

        return obj_dict
Exemple #18
0
    def sequencing_hook(self, db_session, parent_block_data,
                        parent_sequenced_block_data):

        for account_audit in AccountAudit.query(db_session).filter_by(
                block_id=self.block.id).order_by('event_idx'):
            try:
                account = Account.query(db_session).filter_by(
                    id=account_audit.account_id).one()

                if account_audit.type_id == ACCOUNT_AUDIT_TYPE_REAPED:
                    account.count_reaped += 1
                    account.is_reaped = True

                elif account_audit.type_id == ACCOUNT_AUDIT_TYPE_NEW:
                    account.is_reaped = False

                account.updated_at_block = self.block.id

            except NoResultFound:

                account = Account(id=account_audit.account_id,
                                  address=ss58_encode(account_audit.account_id,
                                                      SUBSTRATE_ADDRESS_TYPE),
                                  hash_blake2b=blake2_256(
                                      binascii.unhexlify(
                                          account_audit.account_id)),
                                  created_at_block=self.block.id,
                                  updated_at_block=self.block.id,
                                  balance=0)

                # Retrieve index in corresponding account
                account_index = AccountIndex.query(db_session).filter_by(
                    account_id=account.id).first()

                if account_index:

                    account.index_address = account_index.short_address
                    account.save(db_session)

                # # If reaped but does not exist, create new account for now
                # if account_audit.type_id != ACCOUNT_AUDIT_TYPE_NEW:
                #     account.is_reaped = True
                #     account.count_reaped = 1

            account.save(db_session)
    def sequencing_hook(self, db_session, parent_block_data, parent_sequenced_block_data):

        for account_audit in AccountAudit.query(db_session).filter_by(block_id=self.block.id).order_by('event_idx'):
            try:
                account = Account.query(db_session).filter_by(id=account_audit.account_id).one()

                if account_audit.type_id == ACCOUNT_AUDIT_TYPE_REAPED:
                    account.count_reaped += 1
                    account.is_reaped = True

                elif account_audit.type_id == ACCOUNT_AUDIT_TYPE_NEW:
                    account.is_reaped = False

                account.updated_at_block = self.block.id

            except NoResultFound:

                account = Account(
                    id=account_audit.account_id,
                    address=ss58_encode(account_audit.account_id, SUBSTRATE_ADDRESS_TYPE),
                    created_at_block=self.block.id,
                    updated_at_block=self.block.id,
                    balance=0
                )
                ### account balance
                substrate = SubstrateInterface(SUBSTRATE_RPC_URL)
                balance = substrate.get_storage(
                    block_hash=None,
                    module='Balances',
                    function='FreeBalance',
                    params=account_audit.account_id,
                    return_scale_type='Balance',
                    hasher='Blake2_256') or 0

                account.balance = balance
                # If reaped but does not exist, create new account for now
                if account_audit.type_id != ACCOUNT_AUDIT_TYPE_NEW:
                    account.is_reaped = True
                    account.count_reaped = 1

            account.save(db_session)
Exemple #20
0
    def on_get(self, req, resp):
        page = int(req.params.get('page') if req.params.get('page') else 1)
        pageSize = int(
            req.params.get('page_size') if req.params.get('page_size') else 20)

        # blocks = Block.query(self.session).order_by(Block.id.desc()).limit(pageSize).offset((page - 1) * pageSize).all()
        blocks = Block.latest_blocks(self.session, page, pageSize)
        resp.status = falcon.HTTP_200
        result = [
            {
                "block_num":
                blockData.id,
                "event_count":
                blockData.count_events,
                "extrinsics_count":
                blockData.count_extrinsics,
                "block_timestamp":
                blockData.datetime.strftime("%Y-%m-%d %H:%M:%S"),
                "block_hash":
                blockData.hash,
                "author":
                ss58_encode(blockData.author.replace('0x', ''))
                if blockData.author is not None else None,
                # "block_timestamp": time.mktime(blockData.datetime.timetuple()),
                "finalized":
                "1" if blockData.author is not None else None,
            } for blockData in blocks
        ]

        count = Block.query(self.session).count()
        resp.media = {
            'status': 'success',
            'data': {
                'result': result,
                'count': count
            }
        }
 def serialize_formatting_hook(self, obj_dict):
     obj_dict["attributes"]["address"] = ss58_encode(
         self.account_id, SUBSTRATE_ADDRESS_TYPE)
     obj_dict["attributes"]["balance_free_int"] = int(self.balance_free)
     return obj_dict
    def sequencing_hook(self, db_session, parent_block_data, parent_sequenced_block_data):

        for account_audit in AccountAudit.query(db_session).filter_by(block_id=self.block.id).order_by('event_idx'):
            try:
                account = Account.query(db_session).filter_by(id=account_audit.account_id).one()

                if account_audit.type_id == settings.ACCOUNT_AUDIT_TYPE_REAPED:
                    account.count_reaped += 1
                    account.is_reaped = True

                elif account_audit.type_id == settings.ACCOUNT_AUDIT_TYPE_NEW:
                    account.is_reaped = False

                account.updated_at_block = self.block.id

            except NoResultFound:

                account = Account(
                    id=account_audit.account_id,
                    address=ss58_encode(account_audit.account_id, settings.SUBSTRATE_ADDRESS_TYPE),
                    hash_blake2b=blake2_256(binascii.unhexlify(account_audit.account_id)),
                    is_treasury=(account_audit.data or {}).get('is_treasury', False),
                    is_sudo=(account_audit.data or {}).get('is_sudo', False),
                    was_sudo=(account_audit.data or {}).get('is_sudo', False),
                    created_at_block=self.block.id,
                    updated_at_block=self.block.id
                )

                # Retrieve index in corresponding account
                account_index = AccountIndex.query(db_session).filter_by(account_id=account.id).first()

                if account_index:

                    account.index_address = account_index.short_address

                # Retrieve and set initial balance
                try:
                    account_info_data = self.substrate.get_runtime_state(
                        module='System',
                        storage_function='Account',
                        params=['0x{}'.format(account.id)],
                        block_hash=self.block.hash
                    ).get('result')

                    if account_info_data:

                        account.balance_free = account_info_data["data"]["free"]
                        account.balance_reserved = account_info_data["data"]["reserved"]
                        account.balance_total = account_info_data["data"]["free"] + account_info_data["data"]["reserved"]
                        account.nonce = account_info_data["nonce"]
                except ValueError:
                    pass

                # # If reaped but does not exist, create new account for now
                # if account_audit.type_id != ACCOUNT_AUDIT_TYPE_NEW:
                #     account.is_reaped = True
                #     account.count_reaped = 1

            account.save(db_session)

        # Until SUDO and batch calls are processed separately we need to do a safety check to be sure we include all
        # accounts that have activity (lookup in account_index) in current block
        # TODO implement calls

        for search_index in db_session.query(SearchIndex.account_id).filter(
                SearchIndex.block_id == self.block.id,
                SearchIndex.account_id.notin_(db_session.query(Account.id))
        ).distinct():

            account = Account(
                id=search_index.account_id,
                address=ss58_encode(search_index.account_id, settings.SUBSTRATE_ADDRESS_TYPE),
                hash_blake2b=blake2_256(binascii.unhexlify(search_index.account_id)),
                created_at_block=self.block.id,
                updated_at_block=self.block.id
            )

            try:
                account_info_data = self.substrate.get_runtime_state(
                    module='System',
                    storage_function='Account',
                    params=['0x{}'.format(account.id)],
                    block_hash=self.block.hash
                ).get('result')

                if account_info_data:
                    account.balance_free = account_info_data["data"]["free"]
                    account.balance_reserved = account_info_data["data"]["reserved"]
                    account.balance_total = account_info_data["data"]["free"] + account_info_data["data"]["reserved"]
                    account.nonce = account_info_data["nonce"]
            except ValueError:
                pass

            account.save(db_session)
Exemple #23
0
    def on_post(self, req, resp):
        blockHash = None
        if req.media.get('block_id'):
            substrate = SubstrateInterface(url=SUBSTRATE_RPC_URL,
                                           address_type=SUBSTRATE_ADDRESS_TYPE,
                                           type_registry_preset=TYPE_REGISTRY)
            blockHash = substrate.get_block_hash(req.media.get('block_id'))
        elif req.media.get('block_hash'):
            blockHash = req.media.get('block_hash')
        else:
            resp.status = falcon.HTTP_BAD_REQUEST
            resp.media = {
                'errors': ['Either blockHash or block_id should be supplied']
            }

        if blockHash:
            resp.status = falcon.HTTP_200
            block = Block.query(
                self.session).filter(Block.hash == blockHash).first()
            blockTotal = BlockTotal.query(
                self.session).filter(BlockTotal.id == block.id).first()
            author = ss58_encode(
                blockTotal.author.replace('0x', '')
            ) if blockTotal is not None and blockTotal.author is not None else None

            if block:
                blockInfo = {}
                blockInfo["timestamp"] = block.datetime.strftime(
                    "%Y-%m-%d %H:%M:%S")
                blockInfo["block_hash"] = block.hash
                blockInfo["block_id"] = block.id
                blockInfo["parent_id"] = block.id - 1 if block.id > 0 else 0
                blockInfo["child_id"] = block.id + 1
                blockInfo["parent_hash"] = block.parent_hash
                blockInfo["state_root"] = block.state_root
                blockInfo["extrinsic_root"] = block.extrinsics_root
                blockInfo["validator"] = author
                blockInfo["count_extrinsic"] = block.count_extrinsics
                blockInfo["count_event"] = block.count_events
                blockInfo["count_log"] = block.count_log
                # blockInfo["age"] = time.mktime(block.datetime.timetuple())
                blockInfo["age"] = block.datetime.strftime("%Y-%m-%d %H:%M:%S")

                # 获取和区块相关的交易信息
                extrinsics = Extrinsic.query(
                    self.session).filter(Extrinsic.block_id == block.id).all()
                extrinsicsObj = [
                    {
                        "extrinsic_id":
                        '{}-{}'.format(block.id, extrinsic.extrinsic_idx),
                        "hash":
                        extrinsic.extrinsic_hash
                        if extrinsic.extrinsic_hash else None,
                        # "age": time.mktime(block.datetime.timetuple()),
                        "age":
                        block.datetime.strftime("%Y-%m-%d %H:%M:%S"),
                        "result":
                        extrinsic.success,
                        # "address": extrinsic.address if extrinsic.address else None,
                        # "module": extrinsic.module_id,
                        # "fee": None,
                        # "nonce": extrinsic.nonce if extrinsic.nonce else None,
                        # "call": extrinsic.call_id,
                        "operation":
                        '{}({})'.format(extrinsic.module_id,
                                        extrinsic.call_id),
                        "params":
                        extrinsic.params
                        # "signature": extrinsic.signature if extrinsic.signature else None
                    } for extrinsic in extrinsics
                ]

                # 获取和区块相关的日志信息
                logs = Log.query(
                    self.session).filter(Log.block_id == block.id).all()
                logsObj = [{
                    "log_id": '{}-{}'.format(block.id, log.log_idx),
                    "block_id": block.id,
                    "type": log.type,
                    "data": log.data['value']
                } for log in logs]

                # 获取和区块相关的事件信息
                events = Event.query(
                    self.session).filter(Event.block_id == block.id).all()
                eventObj = [{
                    "id":
                    '{}-{}'.format(block.id, event.event_idx),
                    "block_id":
                    block.id,
                    "block_hash":
                    block.hash,
                    "module_id":
                    event.module_id,
                    "event_id":
                    event.event_id,
                    "attributes":
                    event.attributes,
                    "operation":
                    '{}({})'.format(event.module_id, event.event_id),
                    "desc":
                    self.getEventDesc(event.module_id, event.event_id),
                    "hash":
                    self.getEventHash(block.id, event.extrinsic_idx)
                } for event in events]

                resp.media = {
                    'status': 'success',
                    'data': {
                        "block_info": blockInfo,
                        "extrinsics": extrinsicsObj,
                        "logs": logsObj,
                        "events": eventObj
                    }
                }
        else:
            resp.status = falcon.HTTP_404
            resp.media = {'result': 'Block not found'}
Exemple #24
0
    def on_get(self, req, resp):
        resp.status = falcon.HTTP_200
        extrinsicId = req.params.get('extrinsic_id')
        if extrinsicId is None:
            resp.status = falcon.HTTP_BAD_REQUEST
            resp.media = {'errors': ['Invalid extrinsic id']}

        split = extrinsicId.split("-")
        if split is None or len(split) != 2:
            resp.status = falcon.HTTP_BAD_REQUEST
            resp.media = {'errors': ['Invalid extrinsic id']}

        blockId = split[0]
        extrinsicIdx = split[1]
        extrinsic = Extrinsic.extrinsic_by_id(self.session, blockId,
                                              extrinsicIdx).first()
        print(extrinsic.extrinsic_idx)
        extrinsicDetailInfo = {}
        if extrinsic is not None:
            extrinsicDetailInfo["extrinsic_id"] = '{}-{}'.format(
                extrinsic.block_id, extrinsic.extrinsic_idx)
            extrinsicDetailInfo["block_id"] = extrinsic.block_id
            extrinsicDetailInfo["extrinsic_idx"] = extrinsic.extrinsic_idx
            extrinsicDetailInfo["hash"] = "0x{}".format(
                extrinsic.extrinsic_hash) if extrinsic.extrinsic_hash else None
            extrinsicDetailInfo["age"] = extrinsic.datetime.strftime(
                "%Y-%m-%d %H:%M:%S")
            extrinsicDetailInfo["result"] = extrinsic.success
            extrinsicDetailInfo["operation"] = '{}({})'.format(
                extrinsic.module_id, extrinsic.call_id)
            extrinsicDetailInfo["module_id"] = extrinsic.module_id
            extrinsicDetailInfo["call_id"] = extrinsic.call_id
            extrinsicDetailInfo[
                "module_name"] = extrinsic.module_name.capitalize()
            extrinsicDetailInfo["call_name"] = extrinsic.call_name.capitalize()
            extrinsicDetailInfo["call_desc"] = extrinsic.call_desc
            extrinsicDetailInfo["nonce"] = int(
                extrinsic.nonce) if extrinsic.nonce else None
            extrinsicDetailInfo[
                "signature"] = extrinsic.signature if extrinsic.signature else None
            extrinsicDetailInfo["params"] = extrinsic.params
            extrinsicDetailInfo["from"] = extrinsic.address.replace(
                '0x', '') if extrinsic.address else None
            extrinsicDetailInfo["from_addr"] = ss58_encode(
                extrinsic.address.replace('0x',
                                          '')) if extrinsic.address else None

            params = json.loads(extrinsic.params)
            for param in params:
                name = param.get('name')
                if name == 'dest':
                    toAddr = ss58_encode(param.get('value').replace('0x', ''))
                    extrinsicDetailInfo['to'] = param.get('value').replace(
                        '0x', '')
                    extrinsicDetailInfo['to_addr'] = toAddr
                elif name == 'value':
                    coin = param.get('value') / 1000000000000  # 转换为单位 Unit
                    extrinsicDetailInfo['coin'] = coin

            # 获取和区块相关的事件信息
            events = Event.query(self.session).filter(
                Event.block_id == extrinsic.block_id).all()
            eventObj = [{
                "id":
                '{}-{}'.format(extrinsic.block_id, event.event_idx),
                "block_id":
                extrinsic.block_id,
                "module_id":
                event.module_id,
                "event_id":
                event.event_id,
                "attributes":
                event.attributes,
                "operation":
                '{}({})'.format(event.module_id, event.event_id),
                "desc":
                self.getEventDesc(event.module_id, event.event_id),
                "hash":
                self.getEventHash(extrinsic.block_id, event.extrinsic_idx)
            } for event in events]

        resp.media = {
            'status': 'success',
            'data': {
                "extrinsic_detail": extrinsicDetailInfo,
                "events": eventObj,
                "event_count": len(eventObj)
            }
        }
 def format_address(self, item):
     item['orig_value'] = item['value'].replace('0x', '')
     item['value'] = ss58_encode(item['value'].replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)
     return item
    def serialize_formatting_hook(self, obj_dict):
        obj_dict['attributes']['vote_address'] = ss58_encode(self.vote_account_id.replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)
        obj_dict['attributes']['stash_address'] = ss58_encode(self.stash_account_id.replace('0x', ''), SUBSTRATE_ADDRESS_TYPE)

        return obj_dict