Upload 50 random repository samples

9d3c8f5 verified about 1 year ago

8.43 kB

# Python Substrate Interface Library
#
# Copyright 2018-2023 Stichting Polkascan (Polkascan Foundation).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

import math
from datetime import datetime, timedelta

__all__ = ['Extension', 'SearchExtension', 'SubstrateNodeExtension']

if TYPE_CHECKING:
    from .base import SubstrateInterface


class Extension:
    """
    Base class of all extensions
    """
    def __init__(self):
        self.substrate = None

    def init(self, substrate: 'SubstrateInterface'):
        """
        Initialization process of the extension. This function is being called by the ExtensionRegistry.
        Parameters
        ----------
        substrate: SubstrateInterface
        Returns
        -------
        """
        self.substrate: 'SubstrateInterface' = substrate

    def close(self):
        """
        Cleanup process of the extension. This function is being called by the ExtensionRegistry.
        Returns
        -------
        """
        pass

    def debug_message(self, message: str):
        """
        Submits a debug message in the logger
        Parameters
        ----------
        message: str
        Returns
        -------
        """
        self.substrate.debug_message(f'Extension {self.__class__.__name__}: {message}')


class SearchExtension(Extension):
    """
    Type of `Extension` that implements functionality to improve and enhance search capability
    """

    def filter_events(self, **kwargs) -> list:
        """
        Filters events to match provided search criteria e.g. block range, pallet name, accountID in attributes
        Parameters
        ----------
        kwargs
        Returns
        -------
        list
        """
        raise NotImplementedError()

    def filter_extrinsics(self, **kwargs) -> list:
        """
        Filters extrinsics to match provided search criteria e.g. block range, pallet name, signed by accountID
        Parameters
        ----------
        kwargs
        Returns
        -------
        """
        raise NotImplementedError()

    def search_block_number(self, block_datetime: datetime, block_time: int = 6, **kwargs) -> int:
        """
        Search corresponding block number for provided `block_datetime`. the prediction tolerance is provided with
        `block_time`
        Parameters
        ----------
        block_datetime: datetime
        block_time: int
        kwargs
        Returns
        -------
        int
        """
        raise NotImplementedError()

    def get_block_timestamp(self, block_number: int) -> int:
        """
        Return a UNIX timestamp for given `block_number`.
        Parameters
        ----------
        block_number: int The block_number to retrieve the timestamp for
        Returns
        -------
        int
        """
        raise NotImplementedError()


class SubstrateNodeExtension(SearchExtension):
    """
    Implementation of `SearchExtension` using only Substrate RPC methods. Could be significant inefficient.
    """

    def filter_extrinsics(self, block_start: int = None, block_end: int = None, ss58_address: str = None,
                          pallet_name: str = None, call_name: str = None) -> list:

        if block_end is None:
            block_end = self.substrate.get_block_number(None)

        if block_start is None:
            block_start = block_end

        if block_start < 0:
            block_start += block_end

        result = []

        for block_number in range(block_start, block_end + 1):
            block_hash = self.substrate.get_block_hash(block_number)

            for extrinsic in self.substrate.get_extrinsics(block_hash=block_hash):
                if pallet_name is not None and pallet_name != extrinsic.value['call']['call_module']:
                    continue

                if call_name is not None and call_name != extrinsic.value['call']['call_function']:
                    continue

                result.append(extrinsic)

        return result

    def __init__(self, max_block_range: int = 100):
        super().__init__()

        self.max_block_range: int = max_block_range

    def filter_events(self, block_start: int = None, block_end: int = None, pallet_name: str = None,
                      event_name: str = None, account_id: str = None) -> list:

        if block_end is None:
            block_end = self.substrate.get_block_number(None)

        if block_start is None:
            block_start = block_end

        if block_start < 0:
            block_start += block_end

        # Requirements check
        if block_end - block_start > self.max_block_range:
            raise ValueError(f"max_block_range ({self.max_block_range}) exceeded")

        result = []

        self.debug_message(f"Retrieving events from #{block_start} to #{block_end}")

        for block_number in range(block_start, block_end + 1):
            block_hash = self.substrate.get_block_hash(block_number)
            for event in self.substrate.get_events(block_hash=block_hash):
                if pallet_name is not None and pallet_name != event.value['event']['module_id']:
                    continue

                if event_name is not None and event_name != event.value['event']['event_id']:
                    continue

                # if account_id is not None:
                #     found = False
                #     for param in event.params:
                #         if param['type'] == 'AccountId' and param['value'] == account_id:
                #             found = True
                #             break
                #     if not found:
                #         continue

                result.append(event)

        return result

    def get_block_timestamp(self, block_number: int) -> int:
        extrinsics = self.filter_extrinsics(
            block_start=block_number, block_end=block_number, pallet_name="Timestamp",
            call_name="set"
        )
        return extrinsics[0].value['call']['call_args'][0]['value'] / 1000

    def search_block_number(self, block_datetime: datetime, block_time: int = 6, **kwargs) -> int:
        """
        Search corresponding block number for provided `block_datetime`. the prediction tolerance is provided with
        `block_time`
        Parameters
        ----------
        block_datetime: datetime
        block_time: int
        kwargs
        Returns
        -------
        int
        """
        accuracy = timedelta(seconds=block_time)

        target_block_timestamp = block_datetime.timestamp()

        # Retrieve Timestamp extrinsic for chain tip
        predicted_block_number = self.substrate.get_block_number(None)
        current_timestamp = self.get_block_timestamp(predicted_block_number)
        current_delta = current_timestamp - target_block_timestamp

        self.debug_message(f"Delta {current_delta} sec with chain tip #{predicted_block_number}")

        if current_delta < 0:
            raise ValueError("Requested block_datetime is higher than current chain tip")

        while accuracy < timedelta(seconds=math.fabs(current_delta)):

            predicted_block_number = math.ceil(predicted_block_number - current_delta / block_time)

            if predicted_block_number < 0:
                raise ValueError(f"Requested datetime points before genesis of chain (#{predicted_block_number})")

            current_timestamp = self.get_block_timestamp(predicted_block_number)

            # Predict target block number
            current_delta = current_timestamp - target_block_timestamp

            self.debug_message(f"Current delta {current_delta} sec; predicted #{predicted_block_number}")

        self.debug_message(f"Accepted prediction #{predicted_block_number}")

        return predicted_block_number


# Backwards compatibility
class SubstrateNodeSearchExtension(SubstrateNodeExtension):
    pass

	# Python Substrate Interface Library
	#
	# Copyright 2018-2023 Stichting Polkascan (Polkascan Foundation).
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	from typing import TYPE_CHECKING

	import math
	from datetime import datetime, timedelta

	__all__ = ['Extension', 'SearchExtension', 'SubstrateNodeExtension']

	if TYPE_CHECKING:
	from .base import SubstrateInterface


	class Extension:
	"""
	Base class of all extensions
	"""
	def __init__(self):
	self.substrate = None

	def init(self, substrate: 'SubstrateInterface'):
	"""
	Initialization process of the extension. This function is being called by the ExtensionRegistry.

	Parameters
	----------
	substrate: SubstrateInterface

	Returns
	-------

	"""
	self.substrate: 'SubstrateInterface' = substrate

	def close(self):
	"""
	Cleanup process of the extension. This function is being called by the ExtensionRegistry.

	Returns
	-------

	"""
	pass

	def debug_message(self, message: str):
	"""
	Submits a debug message in the logger

	Parameters
	----------
	message: str

	Returns
	-------

	"""
	self.substrate.debug_message(f'Extension {self.__class__.__name__}: {message}')


	class SearchExtension(Extension):
	"""
	Type of `Extension` that implements functionality to improve and enhance search capability
	"""

	def filter_events(self, **kwargs) -> list:
	"""
	Filters events to match provided search criteria e.g. block range, pallet name, accountID in attributes

	Parameters
	----------
	kwargs

	Returns
	-------
	list
	"""
	raise NotImplementedError()

	def filter_extrinsics(self, **kwargs) -> list:
	"""
	Filters extrinsics to match provided search criteria e.g. block range, pallet name, signed by accountID

	Parameters
	----------
	kwargs

	Returns
	-------

	"""
	raise NotImplementedError()

	def search_block_number(self, block_datetime: datetime, block_time: int = 6, **kwargs) -> int:
	"""
	Search corresponding block number for provided `block_datetime`. the prediction tolerance is provided with
	`block_time`

	Parameters
	----------
	block_datetime: datetime
	block_time: int
	kwargs

	Returns
	-------
	int
	"""
	raise NotImplementedError()

	def get_block_timestamp(self, block_number: int) -> int:
	"""
	Return a UNIX timestamp for given `block_number`.

	Parameters
	----------
	block_number: int The block_number to retrieve the timestamp for

	Returns
	-------
	int
	"""
	raise NotImplementedError()


	class SubstrateNodeExtension(SearchExtension):
	"""
	Implementation of `SearchExtension` using only Substrate RPC methods. Could be significant inefficient.
	"""

	def filter_extrinsics(self, block_start: int = None, block_end: int = None, ss58_address: str = None,
	pallet_name: str = None, call_name: str = None) -> list:

	if block_end is None:
	block_end = self.substrate.get_block_number(None)

	if block_start is None:
	block_start = block_end

	if block_start < 0:
	block_start += block_end

	result = []

	for block_number in range(block_start, block_end + 1):
	block_hash = self.substrate.get_block_hash(block_number)

	for extrinsic in self.substrate.get_extrinsics(block_hash=block_hash):
	if pallet_name is not None and pallet_name != extrinsic.value['call']['call_module']:
	continue

	if call_name is not None and call_name != extrinsic.value['call']['call_function']:
	continue

	result.append(extrinsic)

	return result

	def __init__(self, max_block_range: int = 100):
	super().__init__()

	self.max_block_range: int = max_block_range

	def filter_events(self, block_start: int = None, block_end: int = None, pallet_name: str = None,
	event_name: str = None, account_id: str = None) -> list:

	if block_end is None:
	block_end = self.substrate.get_block_number(None)

	if block_start is None:
	block_start = block_end

	if block_start < 0:
	block_start += block_end

	# Requirements check
	if block_end - block_start > self.max_block_range:
	raise ValueError(f"max_block_range ({self.max_block_range}) exceeded")

	result = []

	self.debug_message(f"Retrieving events from #{block_start} to #{block_end}")

	for block_number in range(block_start, block_end + 1):
	block_hash = self.substrate.get_block_hash(block_number)
	for event in self.substrate.get_events(block_hash=block_hash):
	if pallet_name is not None and pallet_name != event.value['event']['module_id']:
	continue

	if event_name is not None and event_name != event.value['event']['event_id']:
	continue

	# if account_id is not None:
	# found = False
	# for param in event.params:
	# if param['type'] == 'AccountId' and param['value'] == account_id:
	# found = True
	# break
	# if not found:
	# continue

	result.append(event)

	return result

	def get_block_timestamp(self, block_number: int) -> int:
	extrinsics = self.filter_extrinsics(
	block_start=block_number, block_end=block_number, pallet_name="Timestamp",
	call_name="set"
	)
	return extrinsics[0].value['call']['call_args'][0]['value'] / 1000

	def search_block_number(self, block_datetime: datetime, block_time: int = 6, **kwargs) -> int:
	"""
	Search corresponding block number for provided `block_datetime`. the prediction tolerance is provided with
	`block_time`

	Parameters
	----------
	block_datetime: datetime
	block_time: int
	kwargs

	Returns
	-------
	int
	"""
	accuracy = timedelta(seconds=block_time)

	target_block_timestamp = block_datetime.timestamp()

	# Retrieve Timestamp extrinsic for chain tip
	predicted_block_number = self.substrate.get_block_number(None)
	current_timestamp = self.get_block_timestamp(predicted_block_number)
	current_delta = current_timestamp - target_block_timestamp

	self.debug_message(f"Delta {current_delta} sec with chain tip #{predicted_block_number}")

	if current_delta < 0:
	raise ValueError("Requested block_datetime is higher than current chain tip")

	while accuracy < timedelta(seconds=math.fabs(current_delta)):

	predicted_block_number = math.ceil(predicted_block_number - current_delta / block_time)

	if predicted_block_number < 0:
	raise ValueError(f"Requested datetime points before genesis of chain (#{predicted_block_number})")

	current_timestamp = self.get_block_timestamp(predicted_block_number)

	# Predict target block number
	current_delta = current_timestamp - target_block_timestamp

	self.debug_message(f"Current delta {current_delta} sec; predicted #{predicted_block_number}")

	self.debug_message(f"Accepted prediction #{predicted_block_number}")

	return predicted_block_number


	# Backwards compatibility
	class SubstrateNodeSearchExtension(SubstrateNodeExtension):
	pass