id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1
value | code stringlengths 51 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
243,900 | ethereum/py-evm | eth/db/chain.py | ChainDB.get_block_transactions | def get_block_transactions(
self,
header: BlockHeader,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
"""
Returns an iterable of transactions for the block speficied by the
given block header.
"""
return self._get_b... | python | def get_block_transactions(
self,
header: BlockHeader,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
return self._get_block_transactions(header.transaction_root, transaction_class) | [
"def",
"get_block_transactions",
"(",
"self",
",",
"header",
":",
"BlockHeader",
",",
"transaction_class",
":",
"Type",
"[",
"'BaseTransaction'",
"]",
")",
"->",
"Iterable",
"[",
"'BaseTransaction'",
"]",
":",
"return",
"self",
".",
"_get_block_transactions",
"(",... | Returns an iterable of transactions for the block speficied by the
given block header. | [
"Returns",
"an",
"iterable",
"of",
"transactions",
"for",
"the",
"block",
"speficied",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L315-L323 |
243,901 | ethereum/py-evm | eth/db/chain.py | ChainDB.get_block_transaction_hashes | def get_block_transaction_hashes(self, block_header: BlockHeader) -> Iterable[Hash32]:
"""
Returns an iterable of the transaction hashes from the block specified
by the given block header.
"""
return self._get_block_transaction_hashes(self.db, block_header) | python | def get_block_transaction_hashes(self, block_header: BlockHeader) -> Iterable[Hash32]:
return self._get_block_transaction_hashes(self.db, block_header) | [
"def",
"get_block_transaction_hashes",
"(",
"self",
",",
"block_header",
":",
"BlockHeader",
")",
"->",
"Iterable",
"[",
"Hash32",
"]",
":",
"return",
"self",
".",
"_get_block_transaction_hashes",
"(",
"self",
".",
"db",
",",
"block_header",
")"
] | Returns an iterable of the transaction hashes from the block specified
by the given block header. | [
"Returns",
"an",
"iterable",
"of",
"the",
"transaction",
"hashes",
"from",
"the",
"block",
"specified",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L325-L330 |
243,902 | ethereum/py-evm | eth/db/chain.py | ChainDB.get_receipts | def get_receipts(self,
header: BlockHeader,
receipt_class: Type[Receipt]) -> Iterable[Receipt]:
"""
Returns an iterable of receipts for the block specified by the given
block header.
"""
receipt_db = HexaryTrie(db=self.db, root_hash=heade... | python | def get_receipts(self,
header: BlockHeader,
receipt_class: Type[Receipt]) -> Iterable[Receipt]:
receipt_db = HexaryTrie(db=self.db, root_hash=header.receipt_root)
for receipt_idx in itertools.count():
receipt_key = rlp.encode(receipt_idx)
... | [
"def",
"get_receipts",
"(",
"self",
",",
"header",
":",
"BlockHeader",
",",
"receipt_class",
":",
"Type",
"[",
"Receipt",
"]",
")",
"->",
"Iterable",
"[",
"Receipt",
"]",
":",
"receipt_db",
"=",
"HexaryTrie",
"(",
"db",
"=",
"self",
".",
"db",
",",
"ro... | Returns an iterable of receipts for the block specified by the given
block header. | [
"Returns",
"an",
"iterable",
"of",
"receipts",
"for",
"the",
"block",
"specified",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L346-L360 |
243,903 | ethereum/py-evm | eth/db/chain.py | ChainDB.get_transaction_by_index | def get_transaction_by_index(
self,
block_number: BlockNumber,
transaction_index: int,
transaction_class: Type['BaseTransaction']) -> 'BaseTransaction':
"""
Returns the transaction at the specified `transaction_index` from the
block specified by `b... | python | def get_transaction_by_index(
self,
block_number: BlockNumber,
transaction_index: int,
transaction_class: Type['BaseTransaction']) -> 'BaseTransaction':
try:
block_header = self.get_canonical_block_header_by_number(block_number)
except HeaderNo... | [
"def",
"get_transaction_by_index",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
",",
"transaction_index",
":",
"int",
",",
"transaction_class",
":",
"Type",
"[",
"'BaseTransaction'",
"]",
")",
"->",
"'BaseTransaction'",
":",
"try",
":",
"block_header",
"=... | Returns the transaction at the specified `transaction_index` from the
block specified by `block_number` from the canonical chain.
Raises TransactionNotFound if no block | [
"Returns",
"the",
"transaction",
"at",
"the",
"specified",
"transaction_index",
"from",
"the",
"block",
"specified",
"by",
"block_number",
"from",
"the",
"canonical",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L362-L384 |
243,904 | ethereum/py-evm | eth/db/chain.py | ChainDB.get_receipt_by_index | def get_receipt_by_index(self,
block_number: BlockNumber,
receipt_index: int) -> Receipt:
"""
Returns the Receipt of the transaction at specified index
for the block header obtained by the specified block number
"""
try:
... | python | def get_receipt_by_index(self,
block_number: BlockNumber,
receipt_index: int) -> Receipt:
try:
block_header = self.get_canonical_block_header_by_number(block_number)
except HeaderNotFound:
raise ReceiptNotFound("Block {} i... | [
"def",
"get_receipt_by_index",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
",",
"receipt_index",
":",
"int",
")",
"->",
"Receipt",
":",
"try",
":",
"block_header",
"=",
"self",
".",
"get_canonical_block_header_by_number",
"(",
"block_number",
")",
"excep... | Returns the Receipt of the transaction at specified index
for the block header obtained by the specified block number | [
"Returns",
"the",
"Receipt",
"of",
"the",
"transaction",
"at",
"specified",
"index",
"for",
"the",
"block",
"header",
"obtained",
"by",
"the",
"specified",
"block",
"number"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L405-L424 |
243,905 | ethereum/py-evm | eth/db/chain.py | ChainDB._get_block_transaction_data | def _get_block_transaction_data(db: BaseDB, transaction_root: Hash32) -> Iterable[Hash32]:
"""
Returns iterable of the encoded transactions for the given block header
"""
transaction_db = HexaryTrie(db, root_hash=transaction_root)
for transaction_idx in itertools.count():
... | python | def _get_block_transaction_data(db: BaseDB, transaction_root: Hash32) -> Iterable[Hash32]:
transaction_db = HexaryTrie(db, root_hash=transaction_root)
for transaction_idx in itertools.count():
transaction_key = rlp.encode(transaction_idx)
if transaction_key in transaction_db:
... | [
"def",
"_get_block_transaction_data",
"(",
"db",
":",
"BaseDB",
",",
"transaction_root",
":",
"Hash32",
")",
"->",
"Iterable",
"[",
"Hash32",
"]",
":",
"transaction_db",
"=",
"HexaryTrie",
"(",
"db",
",",
"root_hash",
"=",
"transaction_root",
")",
"for",
"tran... | Returns iterable of the encoded transactions for the given block header | [
"Returns",
"iterable",
"of",
"the",
"encoded",
"transactions",
"for",
"the",
"given",
"block",
"header"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L427-L437 |
243,906 | ethereum/py-evm | eth/db/chain.py | ChainDB._get_block_transactions | def _get_block_transactions(
self,
transaction_root: Hash32,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
"""
Memoizable version of `get_block_transactions`
"""
for encoded_transaction in self._get_block_transaction_data(... | python | def _get_block_transactions(
self,
transaction_root: Hash32,
transaction_class: Type['BaseTransaction']) -> Iterable['BaseTransaction']:
for encoded_transaction in self._get_block_transaction_data(self.db, transaction_root):
yield rlp.decode(encoded_transaction, s... | [
"def",
"_get_block_transactions",
"(",
"self",
",",
"transaction_root",
":",
"Hash32",
",",
"transaction_class",
":",
"Type",
"[",
"'BaseTransaction'",
"]",
")",
"->",
"Iterable",
"[",
"'BaseTransaction'",
"]",
":",
"for",
"encoded_transaction",
"in",
"self",
".",... | Memoizable version of `get_block_transactions` | [
"Memoizable",
"version",
"of",
"get_block_transactions"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L441-L449 |
243,907 | ethereum/py-evm | eth/db/chain.py | ChainDB._remove_transaction_from_canonical_chain | def _remove_transaction_from_canonical_chain(db: BaseDB, transaction_hash: Hash32) -> None:
"""
Removes the transaction specified by the given hash from the canonical
chain.
"""
db.delete(SchemaV1.make_transaction_hash_to_block_lookup_key(transaction_hash)) | python | def _remove_transaction_from_canonical_chain(db: BaseDB, transaction_hash: Hash32) -> None:
db.delete(SchemaV1.make_transaction_hash_to_block_lookup_key(transaction_hash)) | [
"def",
"_remove_transaction_from_canonical_chain",
"(",
"db",
":",
"BaseDB",
",",
"transaction_hash",
":",
"Hash32",
")",
"->",
"None",
":",
"db",
".",
"delete",
"(",
"SchemaV1",
".",
"make_transaction_hash_to_block_lookup_key",
"(",
"transaction_hash",
")",
")"
] | Removes the transaction specified by the given hash from the canonical
chain. | [
"Removes",
"the",
"transaction",
"specified",
"by",
"the",
"given",
"hash",
"from",
"the",
"canonical",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L452-L457 |
243,908 | ethereum/py-evm | eth/db/chain.py | ChainDB.persist_trie_data_dict | def persist_trie_data_dict(self, trie_data_dict: Dict[Hash32, bytes]) -> None:
"""
Store raw trie data to db from a dict
"""
with self.db.atomic_batch() as db:
for key, value in trie_data_dict.items():
db[key] = value | python | def persist_trie_data_dict(self, trie_data_dict: Dict[Hash32, bytes]) -> None:
with self.db.atomic_batch() as db:
for key, value in trie_data_dict.items():
db[key] = value | [
"def",
"persist_trie_data_dict",
"(",
"self",
",",
"trie_data_dict",
":",
"Dict",
"[",
"Hash32",
",",
"bytes",
"]",
")",
"->",
"None",
":",
"with",
"self",
".",
"db",
".",
"atomic_batch",
"(",
")",
"as",
"db",
":",
"for",
"key",
",",
"value",
"in",
"... | Store raw trie data to db from a dict | [
"Store",
"raw",
"trie",
"data",
"to",
"db",
"from",
"a",
"dict"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/chain.py#L492-L498 |
243,909 | ethereum/py-evm | eth/vm/forks/frontier/blocks.py | FrontierBlock.from_header | def from_header(cls, header: BlockHeader, chaindb: BaseChainDB) -> BaseBlock:
"""
Returns the block denoted by the given block header.
"""
if header.uncles_hash == EMPTY_UNCLE_HASH:
uncles = [] # type: List[BlockHeader]
else:
uncles = chaindb.get_block_un... | python | def from_header(cls, header: BlockHeader, chaindb: BaseChainDB) -> BaseBlock:
if header.uncles_hash == EMPTY_UNCLE_HASH:
uncles = [] # type: List[BlockHeader]
else:
uncles = chaindb.get_block_uncles(header.uncles_hash)
transactions = chaindb.get_block_transactions(heade... | [
"def",
"from_header",
"(",
"cls",
",",
"header",
":",
"BlockHeader",
",",
"chaindb",
":",
"BaseChainDB",
")",
"->",
"BaseBlock",
":",
"if",
"header",
".",
"uncles_hash",
"==",
"EMPTY_UNCLE_HASH",
":",
"uncles",
"=",
"[",
"]",
"# type: List[BlockHeader]",
"else... | Returns the block denoted by the given block header. | [
"Returns",
"the",
"block",
"denoted",
"by",
"the",
"given",
"block",
"header",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/forks/frontier/blocks.py#L104-L119 |
243,910 | ethereum/py-evm | eth/vm/logic/arithmetic.py | shl | def shl(computation: BaseComputation) -> None:
"""
Bitwise left shift
"""
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
if shift_length >= 256:
result = 0
else:
result = (value << shift_length) & constants.UINT_256_MAX
computation.sta... | python | def shl(computation: BaseComputation) -> None:
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
if shift_length >= 256:
result = 0
else:
result = (value << shift_length) & constants.UINT_256_MAX
computation.stack_push(result) | [
"def",
"shl",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"shift_length",
",",
"value",
"=",
"computation",
".",
"stack_pop",
"(",
"num_items",
"=",
"2",
",",
"type_hint",
"=",
"constants",
".",
"UINT256",
")",
"if",
"shift_length",
... | Bitwise left shift | [
"Bitwise",
"left",
"shift"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/arithmetic.py#L186-L197 |
243,911 | ethereum/py-evm | eth/vm/logic/arithmetic.py | sar | def sar(computation: BaseComputation) -> None:
"""
Arithmetic bitwise right shift
"""
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
value = unsigned_to_signed(value)
if shift_length >= 256:
result = 0 if value >= 0 else constants.UINT_255_NEGATIVE... | python | def sar(computation: BaseComputation) -> None:
shift_length, value = computation.stack_pop(num_items=2, type_hint=constants.UINT256)
value = unsigned_to_signed(value)
if shift_length >= 256:
result = 0 if value >= 0 else constants.UINT_255_NEGATIVE_ONE
else:
result = (value >> shift_len... | [
"def",
"sar",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"shift_length",
",",
"value",
"=",
"computation",
".",
"stack_pop",
"(",
"num_items",
"=",
"2",
",",
"type_hint",
"=",
"constants",
".",
"UINT256",
")",
"value",
"=",
"unsign... | Arithmetic bitwise right shift | [
"Arithmetic",
"bitwise",
"right",
"shift"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/arithmetic.py#L214-L226 |
243,912 | ethereum/py-evm | eth/vm/forks/frontier/headers.py | compute_frontier_difficulty | def compute_frontier_difficulty(parent_header: BlockHeader, timestamp: int) -> int:
"""
Computes the difficulty for a frontier block based on the parent block.
"""
validate_gt(timestamp, parent_header.timestamp, title="Header timestamp")
offset = parent_header.difficulty // DIFFICULTY_ADJUSTMENT_DE... | python | def compute_frontier_difficulty(parent_header: BlockHeader, timestamp: int) -> int:
validate_gt(timestamp, parent_header.timestamp, title="Header timestamp")
offset = parent_header.difficulty // DIFFICULTY_ADJUSTMENT_DENOMINATOR
# We set the minimum to the lowest of the protocol minimum and the parent
... | [
"def",
"compute_frontier_difficulty",
"(",
"parent_header",
":",
"BlockHeader",
",",
"timestamp",
":",
"int",
")",
"->",
"int",
":",
"validate_gt",
"(",
"timestamp",
",",
"parent_header",
".",
"timestamp",
",",
"title",
"=",
"\"Header timestamp\"",
")",
"offset",
... | Computes the difficulty for a frontier block based on the parent block. | [
"Computes",
"the",
"difficulty",
"for",
"a",
"frontier",
"block",
"based",
"on",
"the",
"parent",
"block",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/forks/frontier/headers.py#L36-L73 |
243,913 | ethereum/py-evm | eth/vm/forks/frontier/state.py | FrontierTransactionExecutor.build_computation | def build_computation(self,
message: Message,
transaction: BaseOrSpoofTransaction) -> BaseComputation:
"""Apply the message to the VM."""
transaction_context = self.vm_state.get_transaction_context(transaction)
if message.is_create:
... | python | def build_computation(self,
message: Message,
transaction: BaseOrSpoofTransaction) -> BaseComputation:
transaction_context = self.vm_state.get_transaction_context(transaction)
if message.is_create:
is_collision = self.vm_state.has_code_or_n... | [
"def",
"build_computation",
"(",
"self",
",",
"message",
":",
"Message",
",",
"transaction",
":",
"BaseOrSpoofTransaction",
")",
"->",
"BaseComputation",
":",
"transaction_context",
"=",
"self",
".",
"vm_state",
".",
"get_transaction_context",
"(",
"transaction",
")... | Apply the message to the VM. | [
"Apply",
"the",
"message",
"to",
"the",
"VM",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/forks/frontier/state.py#L107-L140 |
243,914 | ethereum/py-evm | eth/vm/stack.py | Stack.push | def push(self, value: Union[int, bytes]) -> None:
"""
Push an item onto the stack.
"""
if len(self.values) > 1023:
raise FullStack('Stack limit reached')
validate_stack_item(value)
self.values.append(value) | python | def push(self, value: Union[int, bytes]) -> None:
if len(self.values) > 1023:
raise FullStack('Stack limit reached')
validate_stack_item(value)
self.values.append(value) | [
"def",
"push",
"(",
"self",
",",
"value",
":",
"Union",
"[",
"int",
",",
"bytes",
"]",
")",
"->",
"None",
":",
"if",
"len",
"(",
"self",
".",
"values",
")",
">",
"1023",
":",
"raise",
"FullStack",
"(",
"'Stack limit reached'",
")",
"validate_stack_item... | Push an item onto the stack. | [
"Push",
"an",
"item",
"onto",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L38-L47 |
243,915 | ethereum/py-evm | eth/vm/stack.py | Stack.pop | def pop(self,
num_items: int,
type_hint: str) -> Union[int, bytes, Tuple[Union[int, bytes], ...]]:
"""
Pop an item off the stack.
Note: This function is optimized for speed over readability.
"""
try:
if num_items == 1:
return n... | python | def pop(self,
num_items: int,
type_hint: str) -> Union[int, bytes, Tuple[Union[int, bytes], ...]]:
try:
if num_items == 1:
return next(self._pop(num_items, type_hint))
else:
return tuple(self._pop(num_items, type_hint))
exce... | [
"def",
"pop",
"(",
"self",
",",
"num_items",
":",
"int",
",",
"type_hint",
":",
"str",
")",
"->",
"Union",
"[",
"int",
",",
"bytes",
",",
"Tuple",
"[",
"Union",
"[",
"int",
",",
"bytes",
"]",
",",
"...",
"]",
"]",
":",
"try",
":",
"if",
"num_it... | Pop an item off the stack.
Note: This function is optimized for speed over readability. | [
"Pop",
"an",
"item",
"off",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L49-L63 |
243,916 | ethereum/py-evm | eth/vm/stack.py | Stack.swap | def swap(self, position: int) -> None:
"""
Perform a SWAP operation on the stack.
"""
idx = -1 * position - 1
try:
self.values[-1], self.values[idx] = self.values[idx], self.values[-1]
except IndexError:
raise InsufficientStack("Insufficient stack ... | python | def swap(self, position: int) -> None:
idx = -1 * position - 1
try:
self.values[-1], self.values[idx] = self.values[idx], self.values[-1]
except IndexError:
raise InsufficientStack("Insufficient stack items for SWAP{0}".format(position)) | [
"def",
"swap",
"(",
"self",
",",
"position",
":",
"int",
")",
"->",
"None",
":",
"idx",
"=",
"-",
"1",
"*",
"position",
"-",
"1",
"try",
":",
"self",
".",
"values",
"[",
"-",
"1",
"]",
",",
"self",
".",
"values",
"[",
"idx",
"]",
"=",
"self",... | Perform a SWAP operation on the stack. | [
"Perform",
"a",
"SWAP",
"operation",
"on",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L89-L97 |
243,917 | ethereum/py-evm | eth/vm/stack.py | Stack.dup | def dup(self, position: int) -> None:
"""
Perform a DUP operation on the stack.
"""
idx = -1 * position
try:
self.push(self.values[idx])
except IndexError:
raise InsufficientStack("Insufficient stack items for DUP{0}".format(position)) | python | def dup(self, position: int) -> None:
idx = -1 * position
try:
self.push(self.values[idx])
except IndexError:
raise InsufficientStack("Insufficient stack items for DUP{0}".format(position)) | [
"def",
"dup",
"(",
"self",
",",
"position",
":",
"int",
")",
"->",
"None",
":",
"idx",
"=",
"-",
"1",
"*",
"position",
"try",
":",
"self",
".",
"push",
"(",
"self",
".",
"values",
"[",
"idx",
"]",
")",
"except",
"IndexError",
":",
"raise",
"Insuf... | Perform a DUP operation on the stack. | [
"Perform",
"a",
"DUP",
"operation",
"on",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/stack.py#L99-L107 |
243,918 | ethereum/py-evm | eth/db/header.py | HeaderDB.get_canonical_block_hash | def get_canonical_block_hash(self, block_number: BlockNumber) -> Hash32:
"""
Returns the block hash for the canonical block at the given number.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain.
"""
return self._get_canonical_b... | python | def get_canonical_block_hash(self, block_number: BlockNumber) -> Hash32:
return self._get_canonical_block_hash(self.db, block_number) | [
"def",
"get_canonical_block_hash",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
")",
"->",
"Hash32",
":",
"return",
"self",
".",
"_get_canonical_block_hash",
"(",
"self",
".",
"db",
",",
"block_number",
")"
] | Returns the block hash for the canonical block at the given number.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain. | [
"Returns",
"the",
"block",
"hash",
"for",
"the",
"canonical",
"block",
"at",
"the",
"given",
"number",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L97-L104 |
243,919 | ethereum/py-evm | eth/db/header.py | HeaderDB.get_canonical_block_header_by_number | def get_canonical_block_header_by_number(self, block_number: BlockNumber) -> BlockHeader:
"""
Returns the block header with the given number in the canonical chain.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain.
"""
return s... | python | def get_canonical_block_header_by_number(self, block_number: BlockNumber) -> BlockHeader:
return self._get_canonical_block_header_by_number(self.db, block_number) | [
"def",
"get_canonical_block_header_by_number",
"(",
"self",
",",
"block_number",
":",
"BlockNumber",
")",
"->",
"BlockHeader",
":",
"return",
"self",
".",
"_get_canonical_block_header_by_number",
"(",
"self",
".",
"db",
",",
"block_number",
")"
] | Returns the block header with the given number in the canonical chain.
Raises BlockNotFound if there's no block header with the given number in the
canonical chain. | [
"Returns",
"the",
"block",
"header",
"with",
"the",
"given",
"number",
"in",
"the",
"canonical",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L120-L127 |
243,920 | ethereum/py-evm | eth/db/header.py | HeaderDB.persist_header_chain | def persist_header_chain(self,
headers: Iterable[BlockHeader]
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Return two iterable of headers, the first containing the new canonical headers,
the second containing the old ... | python | def persist_header_chain(self,
headers: Iterable[BlockHeader]
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
with self.db.atomic_batch() as db:
return self._persist_header_chain(db, headers) | [
"def",
"persist_header_chain",
"(",
"self",
",",
"headers",
":",
"Iterable",
"[",
"BlockHeader",
"]",
")",
"->",
"Tuple",
"[",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
",",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
"]",
":",
"with",
"self",
".... | Return two iterable of headers, the first containing the new canonical headers,
the second containing the old canonical headers | [
"Return",
"two",
"iterable",
"of",
"headers",
"the",
"first",
"containing",
"the",
"new",
"canonical",
"headers",
"the",
"second",
"containing",
"the",
"old",
"canonical",
"headers"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L198-L206 |
243,921 | ethereum/py-evm | eth/db/header.py | HeaderDB._set_as_canonical_chain_head | def _set_as_canonical_chain_head(cls, db: BaseDB, block_hash: Hash32
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
"""
Sets the canonical chain HEAD to the block header as specified by the
given block hash.
:return: a tuple of the hea... | python | def _set_as_canonical_chain_head(cls, db: BaseDB, block_hash: Hash32
) -> Tuple[Tuple[BlockHeader, ...], Tuple[BlockHeader, ...]]:
try:
header = cls._get_block_header_by_hash(db, block_hash)
except HeaderNotFound:
raise ValueError(
... | [
"def",
"_set_as_canonical_chain_head",
"(",
"cls",
",",
"db",
":",
"BaseDB",
",",
"block_hash",
":",
"Hash32",
")",
"->",
"Tuple",
"[",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
",",
"Tuple",
"[",
"BlockHeader",
",",
"...",
"]",
"]",
":",
"try",
":... | Sets the canonical chain HEAD to the block header as specified by the
given block hash.
:return: a tuple of the headers that are newly in the canonical chain, and the headers that
are no longer in the canonical chain | [
"Sets",
"the",
"canonical",
"chain",
"HEAD",
"to",
"the",
"block",
"header",
"as",
"specified",
"by",
"the",
"given",
"block",
"hash",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L286-L320 |
243,922 | ethereum/py-evm | eth/db/header.py | HeaderDB._add_block_number_to_hash_lookup | def _add_block_number_to_hash_lookup(db: BaseDB, header: BlockHeader) -> None:
"""
Sets a record in the database to allow looking up this header by its
block number.
"""
block_number_to_hash_key = SchemaV1.make_block_number_to_hash_lookup_key(
header.block_number
... | python | def _add_block_number_to_hash_lookup(db: BaseDB, header: BlockHeader) -> None:
block_number_to_hash_key = SchemaV1.make_block_number_to_hash_lookup_key(
header.block_number
)
db.set(
block_number_to_hash_key,
rlp.encode(header.hash, sedes=rlp.sedes.binary),
... | [
"def",
"_add_block_number_to_hash_lookup",
"(",
"db",
":",
"BaseDB",
",",
"header",
":",
"BlockHeader",
")",
"->",
"None",
":",
"block_number_to_hash_key",
"=",
"SchemaV1",
".",
"make_block_number_to_hash_lookup_key",
"(",
"header",
".",
"block_number",
")",
"db",
"... | Sets a record in the database to allow looking up this header by its
block number. | [
"Sets",
"a",
"record",
"in",
"the",
"database",
"to",
"allow",
"looking",
"up",
"this",
"header",
"by",
"its",
"block",
"number",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/header.py#L357-L368 |
243,923 | ethereum/py-evm | eth/_utils/headers.py | compute_gas_limit_bounds | def compute_gas_limit_bounds(parent: BlockHeader) -> Tuple[int, int]:
"""
Compute the boundaries for the block gas limit based on the parent block.
"""
boundary_range = parent.gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
upper_bound = parent.gas_limit + boundary_range
lower_bound = max(GAS_LIMIT_MIN... | python | def compute_gas_limit_bounds(parent: BlockHeader) -> Tuple[int, int]:
boundary_range = parent.gas_limit // GAS_LIMIT_ADJUSTMENT_FACTOR
upper_bound = parent.gas_limit + boundary_range
lower_bound = max(GAS_LIMIT_MINIMUM, parent.gas_limit - boundary_range)
return lower_bound, upper_bound | [
"def",
"compute_gas_limit_bounds",
"(",
"parent",
":",
"BlockHeader",
")",
"->",
"Tuple",
"[",
"int",
",",
"int",
"]",
":",
"boundary_range",
"=",
"parent",
".",
"gas_limit",
"//",
"GAS_LIMIT_ADJUSTMENT_FACTOR",
"upper_bound",
"=",
"parent",
".",
"gas_limit",
"+... | Compute the boundaries for the block gas limit based on the parent block. | [
"Compute",
"the",
"boundaries",
"for",
"the",
"block",
"gas",
"limit",
"based",
"on",
"the",
"parent",
"block",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/headers.py#L20-L27 |
243,924 | ethereum/py-evm | eth/_utils/headers.py | compute_gas_limit | def compute_gas_limit(parent_header: BlockHeader, gas_limit_floor: int) -> int:
"""
A simple strategy for adjusting the gas limit.
For each block:
- decrease by 1/1024th of the gas limit from the previous block
- increase by 50% of the total gas used by the previous block
If the value is less... | python | def compute_gas_limit(parent_header: BlockHeader, gas_limit_floor: int) -> int:
if gas_limit_floor < GAS_LIMIT_MINIMUM:
raise ValueError(
"The `gas_limit_floor` value must be greater than the "
"GAS_LIMIT_MINIMUM. Got {0}. Must be greater than "
"{1}".format(gas_limit_f... | [
"def",
"compute_gas_limit",
"(",
"parent_header",
":",
"BlockHeader",
",",
"gas_limit_floor",
":",
"int",
")",
"->",
"int",
":",
"if",
"gas_limit_floor",
"<",
"GAS_LIMIT_MINIMUM",
":",
"raise",
"ValueError",
"(",
"\"The `gas_limit_floor` value must be greater than the \""... | A simple strategy for adjusting the gas limit.
For each block:
- decrease by 1/1024th of the gas limit from the previous block
- increase by 50% of the total gas used by the previous block
If the value is less than the given `gas_limit_floor`:
- increase the gas limit by 1/1024th of the gas limi... | [
"A",
"simple",
"strategy",
"for",
"adjusting",
"the",
"gas",
"limit",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/headers.py#L30-L77 |
243,925 | ethereum/py-evm | eth/_utils/headers.py | generate_header_from_parent_header | def generate_header_from_parent_header(
compute_difficulty_fn: Callable[[BlockHeader, int], int],
parent_header: BlockHeader,
coinbase: Address,
timestamp: Optional[int] = None,
extra_data: bytes = b'') -> BlockHeader:
"""
Generate BlockHeader from state_root and parent_h... | python | def generate_header_from_parent_header(
compute_difficulty_fn: Callable[[BlockHeader, int], int],
parent_header: BlockHeader,
coinbase: Address,
timestamp: Optional[int] = None,
extra_data: bytes = b'') -> BlockHeader:
if timestamp is None:
timestamp = max(int(time.ti... | [
"def",
"generate_header_from_parent_header",
"(",
"compute_difficulty_fn",
":",
"Callable",
"[",
"[",
"BlockHeader",
",",
"int",
"]",
",",
"int",
"]",
",",
"parent_header",
":",
"BlockHeader",
",",
"coinbase",
":",
"Address",
",",
"timestamp",
":",
"Optional",
"... | Generate BlockHeader from state_root and parent_header | [
"Generate",
"BlockHeader",
"from",
"state_root",
"and",
"parent_header"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/headers.py#L80-L113 |
243,926 | ethereum/py-evm | eth/tools/_utils/normalization.py | state_definition_to_dict | def state_definition_to_dict(state_definition: GeneralState) -> AccountState:
"""Convert a state definition to the canonical dict form.
State can either be defined in the canonical form, or as a list of sub states that are then
merged to one. Sub states can either be given as dictionaries themselves, or as... | python | def state_definition_to_dict(state_definition: GeneralState) -> AccountState:
if isinstance(state_definition, Mapping):
state_dict = state_definition
elif isinstance(state_definition, Iterable):
state_dicts = [
assoc_in(
{},
state_item[:-1],
... | [
"def",
"state_definition_to_dict",
"(",
"state_definition",
":",
"GeneralState",
")",
"->",
"AccountState",
":",
"if",
"isinstance",
"(",
"state_definition",
",",
"Mapping",
")",
":",
"state_dict",
"=",
"state_definition",
"elif",
"isinstance",
"(",
"state_definition"... | Convert a state definition to the canonical dict form.
State can either be defined in the canonical form, or as a list of sub states that are then
merged to one. Sub states can either be given as dictionaries themselves, or as tuples where
the last element is the value and all others the keys for this valu... | [
"Convert",
"a",
"state",
"definition",
"to",
"the",
"canonical",
"dict",
"form",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/_utils/normalization.py#L183-L231 |
243,927 | ethereum/py-evm | eth/db/journal.py | Journal.record_changeset | def record_changeset(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
"""
Creates a new changeset. Changesets are referenced by a random uuid4
to prevent collisions between multiple changesets.
"""
if custom_changeset_id is not None:
if custom_changeset_id i... | python | def record_changeset(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
if custom_changeset_id is not None:
if custom_changeset_id in self.journal_data:
raise ValidationError(
"Tried to record with an existing changeset id: %r" % custom_changeset_id
... | [
"def",
"record_changeset",
"(",
"self",
",",
"custom_changeset_id",
":",
"uuid",
".",
"UUID",
"=",
"None",
")",
"->",
"uuid",
".",
"UUID",
":",
"if",
"custom_changeset_id",
"is",
"not",
"None",
":",
"if",
"custom_changeset_id",
"in",
"self",
".",
"journal_da... | Creates a new changeset. Changesets are referenced by a random uuid4
to prevent collisions between multiple changesets. | [
"Creates",
"a",
"new",
"changeset",
".",
"Changesets",
"are",
"referenced",
"by",
"a",
"random",
"uuid4",
"to",
"prevent",
"collisions",
"between",
"multiple",
"changesets",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L93-L109 |
243,928 | ethereum/py-evm | eth/db/journal.py | Journal.pop_changeset | def pop_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
"""
Returns all changes from the given changeset. This includes all of
the changes from any subsequent changeset, giving precidence to
later changesets.
"""
if changeset_id not i... | python | def pop_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
if changeset_id not in self.journal_data:
raise KeyError(changeset_id, "Unknown changeset in JournalDB")
all_ids = tuple(self.journal_data.keys())
changeset_idx = all_ids.index(changeset_id)... | [
"def",
"pop_changeset",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"Dict",
"[",
"bytes",
",",
"Union",
"[",
"bytes",
",",
"DeletedEntry",
"]",
"]",
":",
"if",
"changeset_id",
"not",
"in",
"self",
".",
"journal_data",
":",
"r... | Returns all changes from the given changeset. This includes all of
the changes from any subsequent changeset, giving precidence to
later changesets. | [
"Returns",
"all",
"changes",
"from",
"the",
"given",
"changeset",
".",
"This",
"includes",
"all",
"of",
"the",
"changes",
"from",
"any",
"subsequent",
"changeset",
"giving",
"precidence",
"to",
"later",
"changesets",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L111-L146 |
243,929 | ethereum/py-evm | eth/db/journal.py | Journal.commit_changeset | def commit_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
"""
Collapses all changes for the given changeset into the previous
changesets if it exists.
"""
does_clear = self.has_clear(changeset_id)
changeset_data = self.pop_changeset(c... | python | def commit_changeset(self, changeset_id: uuid.UUID) -> Dict[bytes, Union[bytes, DeletedEntry]]:
does_clear = self.has_clear(changeset_id)
changeset_data = self.pop_changeset(changeset_id)
if not self.is_empty():
# we only have to assign changeset data into the latest changeset if
... | [
"def",
"commit_changeset",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"Dict",
"[",
"bytes",
",",
"Union",
"[",
"bytes",
",",
"DeletedEntry",
"]",
"]",
":",
"does_clear",
"=",
"self",
".",
"has_clear",
"(",
"changeset_id",
")",... | Collapses all changes for the given changeset into the previous
changesets if it exists. | [
"Collapses",
"all",
"changes",
"for",
"the",
"given",
"changeset",
"into",
"the",
"previous",
"changesets",
"if",
"it",
"exists",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L168-L191 |
243,930 | ethereum/py-evm | eth/db/journal.py | JournalDB._validate_changeset | def _validate_changeset(self, changeset_id: uuid.UUID) -> None:
"""
Checks to be sure the changeset is known by the journal
"""
if not self.journal.has_changeset(changeset_id):
raise ValidationError("Changeset not found in journal: {0}".format(
str(changeset_i... | python | def _validate_changeset(self, changeset_id: uuid.UUID) -> None:
if not self.journal.has_changeset(changeset_id):
raise ValidationError("Changeset not found in journal: {0}".format(
str(changeset_id)
)) | [
"def",
"_validate_changeset",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"None",
":",
"if",
"not",
"self",
".",
"journal",
".",
"has_changeset",
"(",
"changeset_id",
")",
":",
"raise",
"ValidationError",
"(",
"\"Changeset not found ... | Checks to be sure the changeset is known by the journal | [
"Checks",
"to",
"be",
"sure",
"the",
"changeset",
"is",
"known",
"by",
"the",
"journal"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L354-L361 |
243,931 | ethereum/py-evm | eth/db/journal.py | JournalDB.record | def record(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
"""
Starts a new recording and returns an id for the associated changeset
"""
return self.journal.record_changeset(custom_changeset_id) | python | def record(self, custom_changeset_id: uuid.UUID = None) -> uuid.UUID:
return self.journal.record_changeset(custom_changeset_id) | [
"def",
"record",
"(",
"self",
",",
"custom_changeset_id",
":",
"uuid",
".",
"UUID",
"=",
"None",
")",
"->",
"uuid",
".",
"UUID",
":",
"return",
"self",
".",
"journal",
".",
"record_changeset",
"(",
"custom_changeset_id",
")"
] | Starts a new recording and returns an id for the associated changeset | [
"Starts",
"a",
"new",
"recording",
"and",
"returns",
"an",
"id",
"for",
"the",
"associated",
"changeset"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L366-L370 |
243,932 | ethereum/py-evm | eth/db/journal.py | JournalDB.discard | def discard(self, changeset_id: uuid.UUID) -> None:
"""
Throws away all journaled data starting at the given changeset
"""
self._validate_changeset(changeset_id)
self.journal.pop_changeset(changeset_id) | python | def discard(self, changeset_id: uuid.UUID) -> None:
self._validate_changeset(changeset_id)
self.journal.pop_changeset(changeset_id) | [
"def",
"discard",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"None",
":",
"self",
".",
"_validate_changeset",
"(",
"changeset_id",
")",
"self",
".",
"journal",
".",
"pop_changeset",
"(",
"changeset_id",
")"
] | Throws away all journaled data starting at the given changeset | [
"Throws",
"away",
"all",
"journaled",
"data",
"starting",
"at",
"the",
"given",
"changeset"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L372-L377 |
243,933 | ethereum/py-evm | eth/db/journal.py | JournalDB.commit | def commit(self, changeset_id: uuid.UUID) -> None:
"""
Commits a given changeset. This merges the given changeset and all
subsequent changesets into the previous changeset giving precidence
to later changesets in case of any conflicting keys.
If this is the base changeset then a... | python | def commit(self, changeset_id: uuid.UUID) -> None:
self._validate_changeset(changeset_id)
journal_data = self.journal.commit_changeset(changeset_id)
if self.journal.is_empty():
# Ensure the journal automatically restarts recording after
# it has been persisted to the und... | [
"def",
"commit",
"(",
"self",
",",
"changeset_id",
":",
"uuid",
".",
"UUID",
")",
"->",
"None",
":",
"self",
".",
"_validate_changeset",
"(",
"changeset_id",
")",
"journal_data",
"=",
"self",
".",
"journal",
".",
"commit_changeset",
"(",
"changeset_id",
")",... | Commits a given changeset. This merges the given changeset and all
subsequent changesets into the previous changeset giving precidence
to later changesets in case of any conflicting keys.
If this is the base changeset then all changes will be written to
the underlying database and the J... | [
"Commits",
"a",
"given",
"changeset",
".",
"This",
"merges",
"the",
"given",
"changeset",
"and",
"all",
"subsequent",
"changesets",
"into",
"the",
"previous",
"changeset",
"giving",
"precidence",
"to",
"later",
"changesets",
"in",
"case",
"of",
"any",
"conflicti... | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/journal.py#L379-L408 |
243,934 | ethereum/py-evm | eth/_utils/bn128.py | FQP_point_to_FQ2_point | def FQP_point_to_FQ2_point(pt: Tuple[FQP, FQP, FQP]) -> Tuple[FQ2, FQ2, FQ2]:
"""
Transform FQP to FQ2 for type hinting.
"""
return (
FQ2(pt[0].coeffs),
FQ2(pt[1].coeffs),
FQ2(pt[2].coeffs),
) | python | def FQP_point_to_FQ2_point(pt: Tuple[FQP, FQP, FQP]) -> Tuple[FQ2, FQ2, FQ2]:
return (
FQ2(pt[0].coeffs),
FQ2(pt[1].coeffs),
FQ2(pt[2].coeffs),
) | [
"def",
"FQP_point_to_FQ2_point",
"(",
"pt",
":",
"Tuple",
"[",
"FQP",
",",
"FQP",
",",
"FQP",
"]",
")",
"->",
"Tuple",
"[",
"FQ2",
",",
"FQ2",
",",
"FQ2",
"]",
":",
"return",
"(",
"FQ2",
"(",
"pt",
"[",
"0",
"]",
".",
"coeffs",
")",
",",
"FQ2",... | Transform FQP to FQ2 for type hinting. | [
"Transform",
"FQP",
"to",
"FQ2",
"for",
"type",
"hinting",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/bn128.py#L34-L42 |
243,935 | ethereum/py-evm | eth/vm/opcode.py | Opcode.as_opcode | def as_opcode(cls: Type[T],
logic_fn: Callable[..., Any],
mnemonic: str,
gas_cost: int) -> Type[T]:
"""
Class factory method for turning vanilla functions into Opcode classes.
"""
if gas_cost:
@functools.wraps(logic_fn)
... | python | def as_opcode(cls: Type[T],
logic_fn: Callable[..., Any],
mnemonic: str,
gas_cost: int) -> Type[T]:
if gas_cost:
@functools.wraps(logic_fn)
def wrapped_logic_fn(computation: 'BaseComputation') -> Any:
"""
... | [
"def",
"as_opcode",
"(",
"cls",
":",
"Type",
"[",
"T",
"]",
",",
"logic_fn",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
",",
"mnemonic",
":",
"str",
",",
"gas_cost",
":",
"int",
")",
"->",
"Type",
"[",
"T",
"]",
":",
"if",
"gas_cost",
":",
"... | Class factory method for turning vanilla functions into Opcode classes. | [
"Class",
"factory",
"method",
"for",
"turning",
"vanilla",
"functions",
"into",
"Opcode",
"classes",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/opcode.py#L52-L80 |
243,936 | ethereum/py-evm | eth/db/account.py | AccountDB._wipe_storage | def _wipe_storage(self, address: Address) -> None:
"""
Wipe out the storage, without explicitly handling the storage root update
"""
account_store = self._get_address_store(address)
self._dirty_accounts.add(address)
account_store.delete() | python | def _wipe_storage(self, address: Address) -> None:
account_store = self._get_address_store(address)
self._dirty_accounts.add(address)
account_store.delete() | [
"def",
"_wipe_storage",
"(",
"self",
",",
"address",
":",
"Address",
")",
"->",
"None",
":",
"account_store",
"=",
"self",
".",
"_get_address_store",
"(",
"address",
")",
"self",
".",
"_dirty_accounts",
".",
"add",
"(",
"address",
")",
"account_store",
".",
... | Wipe out the storage, without explicitly handling the storage root update | [
"Wipe",
"out",
"the",
"storage",
"without",
"explicitly",
"handling",
"the",
"storage",
"root",
"update"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/account.py#L287-L293 |
243,937 | ethereum/py-evm | eth/tools/fixtures/fillers/common.py | setup_main_filler | def setup_main_filler(name: str, environment: Dict[Any, Any]=None) -> Dict[str, Dict[str, Any]]:
"""
Kick off the filler generation process by creating the general filler scaffold with
a test name and general information about the testing environment.
For tests for the main chain, the `environment` par... | python | def setup_main_filler(name: str, environment: Dict[Any, Any]=None) -> Dict[str, Dict[str, Any]]:
return setup_filler(name, merge(DEFAULT_MAIN_ENVIRONMENT, environment or {})) | [
"def",
"setup_main_filler",
"(",
"name",
":",
"str",
",",
"environment",
":",
"Dict",
"[",
"Any",
",",
"Any",
"]",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"Dict",
"[",
"str",
",",
"Any",
"]",
"]",
":",
"return",
"setup_filler",
"(",
"name"... | Kick off the filler generation process by creating the general filler scaffold with
a test name and general information about the testing environment.
For tests for the main chain, the `environment` parameter is expected to be a dictionary with
some or all of the following keys:
+---------------------... | [
"Kick",
"off",
"the",
"filler",
"generation",
"process",
"by",
"creating",
"the",
"general",
"filler",
"scaffold",
"with",
"a",
"test",
"name",
"and",
"general",
"information",
"about",
"the",
"testing",
"environment",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/fillers/common.py#L114-L138 |
243,938 | ethereum/py-evm | eth/tools/fixtures/fillers/common.py | pre_state | def pre_state(*raw_state: GeneralState, filler: Dict[str, Any]) -> None:
"""
Specify the state prior to the test execution. Multiple invocations don't override
the state but extend it instead.
In general, the elements of `state_definitions` are nested dictionaries of the following form:
.. code-bl... | python | def pre_state(*raw_state: GeneralState, filler: Dict[str, Any]) -> None:
@wraps(pre_state)
def _pre_state(filler: Dict[str, Any]) -> Dict[str, Any]:
test_name = get_test_name(filler)
old_pre_state = filler[test_name].get("pre_state", {})
pre_state = normalize_state(raw_state)
de... | [
"def",
"pre_state",
"(",
"*",
"raw_state",
":",
"GeneralState",
",",
"filler",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
")",
"->",
"None",
":",
"@",
"wraps",
"(",
"pre_state",
")",
"def",
"_pre_state",
"(",
"filler",
":",
"Dict",
"[",
"str",
",",
... | Specify the state prior to the test execution. Multiple invocations don't override
the state but extend it instead.
In general, the elements of `state_definitions` are nested dictionaries of the following form:
.. code-block:: python
{
address: {
"nonce": <account nonc... | [
"Specify",
"the",
"state",
"prior",
"to",
"the",
"test",
"execution",
".",
"Multiple",
"invocations",
"don",
"t",
"override",
"the",
"state",
"but",
"extend",
"it",
"instead",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/fillers/common.py#L141-L185 |
243,939 | ethereum/py-evm | eth/tools/fixtures/fillers/common.py | expect | def expect(post_state: Dict[str, Any]=None,
networks: Any=None,
transaction: TransactionDict=None) -> Callable[..., Dict[str, Any]]:
"""
Specify the expected result for the test.
For state tests, multiple expectations can be given, differing in the transaction data, gas
limit, an... | python | def expect(post_state: Dict[str, Any]=None,
networks: Any=None,
transaction: TransactionDict=None) -> Callable[..., Dict[str, Any]]:
return partial(_expect, post_state, networks, transaction) | [
"def",
"expect",
"(",
"post_state",
":",
"Dict",
"[",
"str",
",",
"Any",
"]",
"=",
"None",
",",
"networks",
":",
"Any",
"=",
"None",
",",
"transaction",
":",
"TransactionDict",
"=",
"None",
")",
"->",
"Callable",
"[",
"...",
",",
"Dict",
"[",
"str",
... | Specify the expected result for the test.
For state tests, multiple expectations can be given, differing in the transaction data, gas
limit, and value, in the applicable networks, and as a result also in the post state. VM tests
support only a single expectation with no specified network and no transaction... | [
"Specify",
"the",
"expected",
"result",
"for",
"the",
"test",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/fillers/common.py#L245-L289 |
243,940 | ethereum/py-evm | eth/vm/logic/context.py | calldataload | def calldataload(computation: BaseComputation) -> None:
"""
Load call data into memory.
"""
start_position = computation.stack_pop(type_hint=constants.UINT256)
value = computation.msg.data_as_bytes[start_position:start_position + 32]
padded_value = value.ljust(32, b'\x00')
normalized_value ... | python | def calldataload(computation: BaseComputation) -> None:
start_position = computation.stack_pop(type_hint=constants.UINT256)
value = computation.msg.data_as_bytes[start_position:start_position + 32]
padded_value = value.ljust(32, b'\x00')
normalized_value = padded_value.lstrip(b'\x00')
computation.... | [
"def",
"calldataload",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"start_position",
"=",
"computation",
".",
"stack_pop",
"(",
"type_hint",
"=",
"constants",
".",
"UINT256",
")",
"value",
"=",
"computation",
".",
"msg",
".",
"data_as_b... | Load call data into memory. | [
"Load",
"call",
"data",
"into",
"memory",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/context.py#L39-L49 |
243,941 | ethereum/py-evm | eth/_utils/numeric.py | clamp | def clamp(inclusive_lower_bound: int,
inclusive_upper_bound: int,
value: int) -> int:
"""
Bound the given ``value`` between ``inclusive_lower_bound`` and
``inclusive_upper_bound``.
"""
if value <= inclusive_lower_bound:
return inclusive_lower_bound
elif value >= inclu... | python | def clamp(inclusive_lower_bound: int,
inclusive_upper_bound: int,
value: int) -> int:
if value <= inclusive_lower_bound:
return inclusive_lower_bound
elif value >= inclusive_upper_bound:
return inclusive_upper_bound
else:
return value | [
"def",
"clamp",
"(",
"inclusive_lower_bound",
":",
"int",
",",
"inclusive_upper_bound",
":",
"int",
",",
"value",
":",
"int",
")",
"->",
"int",
":",
"if",
"value",
"<=",
"inclusive_lower_bound",
":",
"return",
"inclusive_lower_bound",
"elif",
"value",
">=",
"i... | Bound the given ``value`` between ``inclusive_lower_bound`` and
``inclusive_upper_bound``. | [
"Bound",
"the",
"given",
"value",
"between",
"inclusive_lower_bound",
"and",
"inclusive_upper_bound",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/numeric.py#L90-L102 |
243,942 | ethereum/py-evm | eth/_utils/numeric.py | integer_squareroot | def integer_squareroot(value: int) -> int:
"""
Return the integer square root of ``value``.
Uses Python's decimal module to compute the square root of ``value`` with
a precision of 128-bits. The value 128 is chosen since the largest square
root of a 256-bit integer is a 128-bit integer.
"""
... | python | def integer_squareroot(value: int) -> int:
if not isinstance(value, int) or isinstance(value, bool):
raise ValueError(
"Value must be an integer: Got: {0}".format(
type(value),
)
)
if value < 0:
raise ValueError(
"Value cannot be negati... | [
"def",
"integer_squareroot",
"(",
"value",
":",
"int",
")",
"->",
"int",
":",
"if",
"not",
"isinstance",
"(",
"value",
",",
"int",
")",
"or",
"isinstance",
"(",
"value",
",",
"bool",
")",
":",
"raise",
"ValueError",
"(",
"\"Value must be an integer: Got: {0}... | Return the integer square root of ``value``.
Uses Python's decimal module to compute the square root of ``value`` with
a precision of 128-bits. The value 128 is chosen since the largest square
root of a 256-bit integer is a 128-bit integer. | [
"Return",
"the",
"integer",
"square",
"root",
"of",
"value",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/numeric.py#L105-L128 |
243,943 | ethereum/py-evm | eth/db/atomic.py | AtomicDBWriteBatch._commit_unless_raises | def _commit_unless_raises(cls, write_target_db: BaseDB) -> Iterator['AtomicDBWriteBatch']:
"""
Commit all writes inside the context, unless an exception was raised.
Although this is technically an external API, it (and this whole class) is only intended
to be used by AtomicDB.
"... | python | def _commit_unless_raises(cls, write_target_db: BaseDB) -> Iterator['AtomicDBWriteBatch']:
readable_write_batch = cls(write_target_db) # type: AtomicDBWriteBatch
try:
yield readable_write_batch
except Exception:
cls.logger.exception(
"Unexpected error ... | [
"def",
"_commit_unless_raises",
"(",
"cls",
",",
"write_target_db",
":",
"BaseDB",
")",
"->",
"Iterator",
"[",
"'AtomicDBWriteBatch'",
"]",
":",
"readable_write_batch",
"=",
"cls",
"(",
"write_target_db",
")",
"# type: AtomicDBWriteBatch",
"try",
":",
"yield",
"read... | Commit all writes inside the context, unless an exception was raised.
Although this is technically an external API, it (and this whole class) is only intended
to be used by AtomicDB. | [
"Commit",
"all",
"writes",
"inside",
"the",
"context",
"unless",
"an",
"exception",
"was",
"raised",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/atomic.py#L116-L137 |
243,944 | ethereum/py-evm | eth/vm/logic/comparison.py | slt | def slt(computation: BaseComputation) -> None:
"""
Signed Lesser Comparison
"""
left, right = map(
unsigned_to_signed,
computation.stack_pop(num_items=2, type_hint=constants.UINT256),
)
if left < right:
result = 1
else:
result = 0
computation.stack_push(... | python | def slt(computation: BaseComputation) -> None:
left, right = map(
unsigned_to_signed,
computation.stack_pop(num_items=2, type_hint=constants.UINT256),
)
if left < right:
result = 1
else:
result = 0
computation.stack_push(signed_to_unsigned(result)) | [
"def",
"slt",
"(",
"computation",
":",
"BaseComputation",
")",
"->",
"None",
":",
"left",
",",
"right",
"=",
"map",
"(",
"unsigned_to_signed",
",",
"computation",
".",
"stack_pop",
"(",
"num_items",
"=",
"2",
",",
"type_hint",
"=",
"constants",
".",
"UINT2... | Signed Lesser Comparison | [
"Signed",
"Lesser",
"Comparison"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/logic/comparison.py#L39-L53 |
243,945 | ethereum/py-evm | eth/tools/builder/chain/builders.py | build | def build(obj: Any, *applicators: Callable[..., Any]) -> Any:
"""
Run the provided object through the series of applicator functions.
If ``obj`` is an instances of :class:`~eth.chains.base.BaseChain` the
applicators will be run on a copy of the chain and thus will not mutate the
provided chain inst... | python | def build(obj: Any, *applicators: Callable[..., Any]) -> Any:
if isinstance(obj, BaseChain):
return pipe(obj, copy(), *applicators)
else:
return pipe(obj, *applicators) | [
"def",
"build",
"(",
"obj",
":",
"Any",
",",
"*",
"applicators",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
")",
"->",
"Any",
":",
"if",
"isinstance",
"(",
"obj",
",",
"BaseChain",
")",
":",
"return",
"pipe",
"(",
"obj",
",",
"copy",
"(",
")",... | Run the provided object through the series of applicator functions.
If ``obj`` is an instances of :class:`~eth.chains.base.BaseChain` the
applicators will be run on a copy of the chain and thus will not mutate the
provided chain instance. | [
"Run",
"the",
"provided",
"object",
"through",
"the",
"series",
"of",
"applicator",
"functions",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L78-L89 |
243,946 | ethereum/py-evm | eth/tools/builder/chain/builders.py | name | def name(class_name: str, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Assign the given name to the chain class.
"""
return chain_class.configure(__name__=class_name) | python | def name(class_name: str, chain_class: Type[BaseChain]) -> Type[BaseChain]:
return chain_class.configure(__name__=class_name) | [
"def",
"name",
"(",
"class_name",
":",
"str",
",",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"return",
"chain_class",
".",
"configure",
"(",
"__name__",
"=",
"class_name",
")"
] | Assign the given name to the chain class. | [
"Assign",
"the",
"given",
"name",
"to",
"the",
"chain",
"class",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L96-L100 |
243,947 | ethereum/py-evm | eth/tools/builder/chain/builders.py | chain_id | def chain_id(chain_id: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Set the ``chain_id`` for the chain class.
"""
return chain_class.configure(chain_id=chain_id) | python | def chain_id(chain_id: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
return chain_class.configure(chain_id=chain_id) | [
"def",
"chain_id",
"(",
"chain_id",
":",
"int",
",",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"return",
"chain_class",
".",
"configure",
"(",
"chain_id",
"=",
"chain_id",
")"
] | Set the ``chain_id`` for the chain class. | [
"Set",
"the",
"chain_id",
"for",
"the",
"chain",
"class",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L104-L108 |
243,948 | ethereum/py-evm | eth/tools/builder/chain/builders.py | fork_at | def fork_at(vm_class: Type[BaseVM], at_block: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Adds the ``vm_class`` to the chain's ``vm_configuration``.
.. code-block:: python
from eth.chains.base import MiningChain
from eth.tools.builder.chain import build, fork_at
Fro... | python | def fork_at(vm_class: Type[BaseVM], at_block: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
if chain_class.vm_configuration is not None:
base_configuration = chain_class.vm_configuration
else:
base_configuration = tuple()
vm_configuration = base_configuration + ((at_block, vm_class... | [
"def",
"fork_at",
"(",
"vm_class",
":",
"Type",
"[",
"BaseVM",
"]",
",",
"at_block",
":",
"int",
",",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"if",
"chain_class",
".",
"vm_configuration",
"is",
... | Adds the ``vm_class`` to the chain's ``vm_configuration``.
.. code-block:: python
from eth.chains.base import MiningChain
from eth.tools.builder.chain import build, fork_at
FrontierOnlyChain = build(MiningChain, fork_at(FrontierVM, 0))
# these two classes are functionally equival... | [
"Adds",
"the",
"vm_class",
"to",
"the",
"chain",
"s",
"vm_configuration",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L112-L148 |
243,949 | ethereum/py-evm | eth/tools/builder/chain/builders.py | enable_pow_mining | def enable_pow_mining(chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Inject on demand generation of the proof of work mining seal on newly
mined blocks into each of the chain's vms.
"""
if not chain_class.vm_configuration:
raise ValidationError("Chain class has no vm_configuration")
... | python | def enable_pow_mining(chain_class: Type[BaseChain]) -> Type[BaseChain]:
if not chain_class.vm_configuration:
raise ValidationError("Chain class has no vm_configuration")
vm_configuration = _mix_in_pow_mining(chain_class.vm_configuration)
return chain_class.configure(vm_configuration=vm_configuratio... | [
"def",
"enable_pow_mining",
"(",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"if",
"not",
"chain_class",
".",
"vm_configuration",
":",
"raise",
"ValidationError",
"(",
"\"Chain class has no vm_configuration\"",
... | Inject on demand generation of the proof of work mining seal on newly
mined blocks into each of the chain's vms. | [
"Inject",
"on",
"demand",
"generation",
"of",
"the",
"proof",
"of",
"work",
"mining",
"seal",
"on",
"newly",
"mined",
"blocks",
"into",
"each",
"of",
"the",
"chain",
"s",
"vms",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L269-L278 |
243,950 | ethereum/py-evm | eth/tools/builder/chain/builders.py | disable_pow_check | def disable_pow_check(chain_class: Type[BaseChain]) -> Type[BaseChain]:
"""
Disable the proof of work validation check for each of the chain's vms.
This allows for block mining without generation of the proof of work seal.
.. note::
blocks mined this way will not be importable on any chain tha... | python | def disable_pow_check(chain_class: Type[BaseChain]) -> Type[BaseChain]:
if not chain_class.vm_configuration:
raise ValidationError("Chain class has no vm_configuration")
if issubclass(chain_class, NoChainSealValidationMixin):
# Seal validation already disabled, hence nothing to change
c... | [
"def",
"disable_pow_check",
"(",
"chain_class",
":",
"Type",
"[",
"BaseChain",
"]",
")",
"->",
"Type",
"[",
"BaseChain",
"]",
":",
"if",
"not",
"chain_class",
".",
"vm_configuration",
":",
"raise",
"ValidationError",
"(",
"\"Chain class has no vm_configuration\"",
... | Disable the proof of work validation check for each of the chain's vms.
This allows for block mining without generation of the proof of work seal.
.. note::
blocks mined this way will not be importable on any chain that does not
have proof of work disabled. | [
"Disable",
"the",
"proof",
"of",
"work",
"validation",
"check",
"for",
"each",
"of",
"the",
"chain",
"s",
"vms",
".",
"This",
"allows",
"for",
"block",
"mining",
"without",
"generation",
"of",
"the",
"proof",
"of",
"work",
"seal",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L309-L335 |
243,951 | ethereum/py-evm | eth/tools/builder/chain/builders.py | genesis | def genesis(chain_class: BaseChain,
db: BaseAtomicDB=None,
params: Dict[str, HeaderParams]=None,
state: GeneralState=None) -> BaseChain:
"""
Initialize the given chain class with the given genesis header parameters
and chain state.
"""
if state is None:
ge... | python | def genesis(chain_class: BaseChain,
db: BaseAtomicDB=None,
params: Dict[str, HeaderParams]=None,
state: GeneralState=None) -> BaseChain:
if state is None:
genesis_state = {} # type: AccountState
else:
genesis_state = _fill_and_normalize_state(state)
gene... | [
"def",
"genesis",
"(",
"chain_class",
":",
"BaseChain",
",",
"db",
":",
"BaseAtomicDB",
"=",
"None",
",",
"params",
":",
"Dict",
"[",
"str",
",",
"HeaderParams",
"]",
"=",
"None",
",",
"state",
":",
"GeneralState",
"=",
"None",
")",
"->",
"BaseChain",
... | Initialize the given chain class with the given genesis header parameters
and chain state. | [
"Initialize",
"the",
"given",
"chain",
"class",
"with",
"the",
"given",
"genesis",
"header",
"parameters",
"and",
"chain",
"state",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L354-L379 |
243,952 | ethereum/py-evm | eth/tools/builder/chain/builders.py | mine_block | def mine_block(chain: MiningChain, **kwargs: Any) -> MiningChain:
"""
Mine a new block on the chain. Header parameters for the new block can be
overridden using keyword arguments.
"""
if not isinstance(chain, MiningChain):
raise ValidationError('`mine_block` may only be used on MiningChain... | python | def mine_block(chain: MiningChain, **kwargs: Any) -> MiningChain:
if not isinstance(chain, MiningChain):
raise ValidationError('`mine_block` may only be used on MiningChain instances')
chain.mine_block(**kwargs)
return chain | [
"def",
"mine_block",
"(",
"chain",
":",
"MiningChain",
",",
"*",
"*",
"kwargs",
":",
"Any",
")",
"->",
"MiningChain",
":",
"if",
"not",
"isinstance",
"(",
"chain",
",",
"MiningChain",
")",
":",
"raise",
"ValidationError",
"(",
"'`mine_block` may only be used o... | Mine a new block on the chain. Header parameters for the new block can be
overridden using keyword arguments. | [
"Mine",
"a",
"new",
"block",
"on",
"the",
"chain",
".",
"Header",
"parameters",
"for",
"the",
"new",
"block",
"can",
"be",
"overridden",
"using",
"keyword",
"arguments",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L386-L395 |
243,953 | ethereum/py-evm | eth/tools/builder/chain/builders.py | import_block | def import_block(block: BaseBlock, chain: BaseChain) -> BaseChain:
"""
Import the provided ``block`` into the chain.
"""
chain.import_block(block)
return chain | python | def import_block(block: BaseBlock, chain: BaseChain) -> BaseChain:
chain.import_block(block)
return chain | [
"def",
"import_block",
"(",
"block",
":",
"BaseBlock",
",",
"chain",
":",
"BaseChain",
")",
"->",
"BaseChain",
":",
"chain",
".",
"import_block",
"(",
"block",
")",
"return",
"chain"
] | Import the provided ``block`` into the chain. | [
"Import",
"the",
"provided",
"block",
"into",
"the",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L411-L416 |
243,954 | ethereum/py-evm | eth/tools/builder/chain/builders.py | copy | def copy(chain: MiningChain) -> MiningChain:
"""
Make a copy of the chain at the given state. Actions performed on the
resulting chain will not affect the original chain.
"""
if not isinstance(chain, MiningChain):
raise ValidationError("`at_block_number` may only be used with 'MiningChain")... | python | def copy(chain: MiningChain) -> MiningChain:
if not isinstance(chain, MiningChain):
raise ValidationError("`at_block_number` may only be used with 'MiningChain")
base_db = chain.chaindb.db
if not isinstance(base_db, AtomicDB):
raise ValidationError("Unsupported database type: {0}".format(typ... | [
"def",
"copy",
"(",
"chain",
":",
"MiningChain",
")",
"->",
"MiningChain",
":",
"if",
"not",
"isinstance",
"(",
"chain",
",",
"MiningChain",
")",
":",
"raise",
"ValidationError",
"(",
"\"`at_block_number` may only be used with 'MiningChain\"",
")",
"base_db",
"=",
... | Make a copy of the chain at the given state. Actions performed on the
resulting chain will not affect the original chain. | [
"Make",
"a",
"copy",
"of",
"the",
"chain",
"at",
"the",
"given",
"state",
".",
"Actions",
"performed",
"on",
"the",
"resulting",
"chain",
"will",
"not",
"affect",
"the",
"original",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L433-L450 |
243,955 | ethereum/py-evm | eth/tools/builder/chain/builders.py | chain_split | def chain_split(*splits: Iterable[Callable[..., Any]]) -> Callable[[BaseChain], Iterable[BaseChain]]: # noqa: E501
"""
Construct and execute multiple concurrent forks of the chain.
Any number of forks may be executed. For each fork, provide an iterable of
commands.
Returns the resulting chain o... | python | def chain_split(*splits: Iterable[Callable[..., Any]]) -> Callable[[BaseChain], Iterable[BaseChain]]: # noqa: E501
if not splits:
raise ValidationError("Cannot use `chain_split` without providing at least one split")
@functools.wraps(chain_split)
@to_tuple
def _chain_split(chain: BaseChain) -... | [
"def",
"chain_split",
"(",
"*",
"splits",
":",
"Iterable",
"[",
"Callable",
"[",
"...",
",",
"Any",
"]",
"]",
")",
"->",
"Callable",
"[",
"[",
"BaseChain",
"]",
",",
"Iterable",
"[",
"BaseChain",
"]",
"]",
":",
"# noqa: E501",
"if",
"not",
"splits",
... | Construct and execute multiple concurrent forks of the chain.
Any number of forks may be executed. For each fork, provide an iterable of
commands.
Returns the resulting chain objects for each fork.
.. code-block:: python
chain_a, chain_b = build(
mining_chain,
chain... | [
"Construct",
"and",
"execute",
"multiple",
"concurrent",
"forks",
"of",
"the",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L453-L486 |
243,956 | ethereum/py-evm | eth/tools/builder/chain/builders.py | at_block_number | def at_block_number(block_number: BlockNumber, chain: MiningChain) -> MiningChain:
"""
Rewind the chain back to the given block number. Calls to things like
``get_canonical_head`` will still return the canonical head of the chain,
however, you can use ``mine_block`` to mine fork chains.
"""
if ... | python | def at_block_number(block_number: BlockNumber, chain: MiningChain) -> MiningChain:
if not isinstance(chain, MiningChain):
raise ValidationError("`at_block_number` may only be used with 'MiningChain")
at_block = chain.get_canonical_block_by_number(block_number)
db = chain.chaindb.db
chain_at_blo... | [
"def",
"at_block_number",
"(",
"block_number",
":",
"BlockNumber",
",",
"chain",
":",
"MiningChain",
")",
"->",
"MiningChain",
":",
"if",
"not",
"isinstance",
"(",
"chain",
",",
"MiningChain",
")",
":",
"raise",
"ValidationError",
"(",
"\"`at_block_number` may onl... | Rewind the chain back to the given block number. Calls to things like
``get_canonical_head`` will still return the canonical head of the chain,
however, you can use ``mine_block`` to mine fork chains. | [
"Rewind",
"the",
"chain",
"back",
"to",
"the",
"given",
"block",
"number",
".",
"Calls",
"to",
"things",
"like",
"get_canonical_head",
"will",
"still",
"return",
"the",
"canonical",
"head",
"of",
"the",
"chain",
"however",
"you",
"can",
"use",
"mine_block",
... | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/builder/chain/builders.py#L490-L502 |
243,957 | ethereum/py-evm | eth/tools/fixtures/loading.py | load_json_fixture | def load_json_fixture(fixture_path: str) -> Dict[str, Any]:
"""
Loads a fixture file, caching the most recent files it loaded.
"""
with open(fixture_path) as fixture_file:
file_fixtures = json.load(fixture_file)
return file_fixtures | python | def load_json_fixture(fixture_path: str) -> Dict[str, Any]:
with open(fixture_path) as fixture_file:
file_fixtures = json.load(fixture_file)
return file_fixtures | [
"def",
"load_json_fixture",
"(",
"fixture_path",
":",
"str",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"with",
"open",
"(",
"fixture_path",
")",
"as",
"fixture_file",
":",
"file_fixtures",
"=",
"json",
".",
"load",
"(",
"fixture_file",
")",
"r... | Loads a fixture file, caching the most recent files it loaded. | [
"Loads",
"a",
"fixture",
"file",
"caching",
"the",
"most",
"recent",
"files",
"it",
"loaded",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/loading.py#L54-L60 |
243,958 | ethereum/py-evm | eth/tools/fixtures/loading.py | load_fixture | def load_fixture(fixture_path: str,
fixture_key: str,
normalize_fn: Callable[..., Any]=identity) -> Dict[str, Any]:
"""
Loads a specific fixture from a fixture file, optionally passing it through
a normalization function.
"""
file_fixtures = load_json_fixture(fixtur... | python | def load_fixture(fixture_path: str,
fixture_key: str,
normalize_fn: Callable[..., Any]=identity) -> Dict[str, Any]:
file_fixtures = load_json_fixture(fixture_path)
fixture = normalize_fn(file_fixtures[fixture_key])
return fixture | [
"def",
"load_fixture",
"(",
"fixture_path",
":",
"str",
",",
"fixture_key",
":",
"str",
",",
"normalize_fn",
":",
"Callable",
"[",
"...",
",",
"Any",
"]",
"=",
"identity",
")",
"->",
"Dict",
"[",
"str",
",",
"Any",
"]",
":",
"file_fixtures",
"=",
"load... | Loads a specific fixture from a fixture file, optionally passing it through
a normalization function. | [
"Loads",
"a",
"specific",
"fixture",
"from",
"a",
"fixture",
"file",
"optionally",
"passing",
"it",
"through",
"a",
"normalization",
"function",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/fixtures/loading.py#L63-L72 |
243,959 | ethereum/py-evm | eth/_utils/version.py | construct_evm_runtime_identifier | def construct_evm_runtime_identifier() -> str:
"""
Constructs the EVM runtime identifier string
e.g. 'Py-EVM/v1.2.3/darwin-amd64/python3.6.5'
"""
return "Py-EVM/{0}/{platform}/{imp.name}{v.major}.{v.minor}.{v.micro}".format(
__version__,
platform=sys.platform,
v=sys.version_... | python | def construct_evm_runtime_identifier() -> str:
return "Py-EVM/{0}/{platform}/{imp.name}{v.major}.{v.minor}.{v.micro}".format(
__version__,
platform=sys.platform,
v=sys.version_info,
# mypy Doesn't recognize the `sys` module as having an `implementation` attribute.
imp=sys.imp... | [
"def",
"construct_evm_runtime_identifier",
"(",
")",
"->",
"str",
":",
"return",
"\"Py-EVM/{0}/{platform}/{imp.name}{v.major}.{v.minor}.{v.micro}\"",
".",
"format",
"(",
"__version__",
",",
"platform",
"=",
"sys",
".",
"platform",
",",
"v",
"=",
"sys",
".",
"version_i... | Constructs the EVM runtime identifier string
e.g. 'Py-EVM/v1.2.3/darwin-amd64/python3.6.5' | [
"Constructs",
"the",
"EVM",
"runtime",
"identifier",
"string"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/version.py#L6-L18 |
243,960 | ethereum/py-evm | eth/estimators/gas.py | binary_gas_search | def binary_gas_search(state: BaseState, transaction: BaseTransaction, tolerance: int=1) -> int:
"""
Run the transaction with various gas limits, progressively
approaching the minimum needed to succeed without an OutOfGas exception.
The starting range of possible estimates is:
[transaction.intrinsic... | python | def binary_gas_search(state: BaseState, transaction: BaseTransaction, tolerance: int=1) -> int:
if not hasattr(transaction, 'sender'):
raise TypeError(
"Transaction is missing attribute sender.",
"If sending an unsigned transaction, use SpoofTransaction and provide the",
... | [
"def",
"binary_gas_search",
"(",
"state",
":",
"BaseState",
",",
"transaction",
":",
"BaseTransaction",
",",
"tolerance",
":",
"int",
"=",
"1",
")",
"->",
"int",
":",
"if",
"not",
"hasattr",
"(",
"transaction",
",",
"'sender'",
")",
":",
"raise",
"TypeErro... | Run the transaction with various gas limits, progressively
approaching the minimum needed to succeed without an OutOfGas exception.
The starting range of possible estimates is:
[transaction.intrinsic_gas, state.gas_limit].
After the first OutOfGas exception, the range is: (largest_limit_out_of_gas, sta... | [
"Run",
"the",
"transaction",
"with",
"various",
"gas",
"limits",
"progressively",
"approaching",
"the",
"minimum",
"needed",
"to",
"succeed",
"without",
"an",
"OutOfGas",
"exception",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/estimators/gas.py#L28-L78 |
243,961 | ethereum/py-evm | eth/db/storage.py | StorageLookup.commit_to | def commit_to(self, db: BaseDB) -> None:
"""
Trying to commit changes when nothing has been written will raise a
ValidationError
"""
self.logger.debug2('persist storage root to data store')
if self._trie_nodes_batch is None:
raise ValidationError(
... | python | def commit_to(self, db: BaseDB) -> None:
self.logger.debug2('persist storage root to data store')
if self._trie_nodes_batch is None:
raise ValidationError(
"It is invalid to commit an account's storage if it has no pending changes. "
"Always check storage_look... | [
"def",
"commit_to",
"(",
"self",
",",
"db",
":",
"BaseDB",
")",
"->",
"None",
":",
"self",
".",
"logger",
".",
"debug2",
"(",
"'persist storage root to data store'",
")",
"if",
"self",
".",
"_trie_nodes_batch",
"is",
"None",
":",
"raise",
"ValidationError",
... | Trying to commit changes when nothing has been written will raise a
ValidationError | [
"Trying",
"to",
"commit",
"changes",
"when",
"nothing",
"has",
"been",
"written",
"will",
"raise",
"a",
"ValidationError"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/storage.py#L131-L143 |
243,962 | ethereum/py-evm | eth/db/storage.py | AccountStorageDB._validate_flushed | def _validate_flushed(self) -> None:
"""
Will raise an exception if there are some changes made since the last persist.
"""
journal_diff = self._journal_storage.diff()
if len(journal_diff) > 0:
raise ValidationError(
"StorageDB had a dirty journal when... | python | def _validate_flushed(self) -> None:
journal_diff = self._journal_storage.diff()
if len(journal_diff) > 0:
raise ValidationError(
"StorageDB had a dirty journal when it needed to be clean: %r" % journal_diff
) | [
"def",
"_validate_flushed",
"(",
"self",
")",
"->",
"None",
":",
"journal_diff",
"=",
"self",
".",
"_journal_storage",
".",
"diff",
"(",
")",
"if",
"len",
"(",
"journal_diff",
")",
">",
"0",
":",
"raise",
"ValidationError",
"(",
"\"StorageDB had a dirty journa... | Will raise an exception if there are some changes made since the last persist. | [
"Will",
"raise",
"an",
"exception",
"if",
"there",
"are",
"some",
"changes",
"made",
"since",
"the",
"last",
"persist",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/storage.py#L243-L251 |
243,963 | ethereum/py-evm | eth/vm/memory.py | Memory.write | def write(self, start_position: int, size: int, value: bytes) -> None:
"""
Write `value` into memory.
"""
if size:
validate_uint256(start_position)
validate_uint256(size)
validate_is_bytes(value)
validate_length(value, length=size)
... | python | def write(self, start_position: int, size: int, value: bytes) -> None:
if size:
validate_uint256(start_position)
validate_uint256(size)
validate_is_bytes(value)
validate_length(value, length=size)
validate_lte(start_position + size, maximum=len(self))
... | [
"def",
"write",
"(",
"self",
",",
"start_position",
":",
"int",
",",
"size",
":",
"int",
",",
"value",
":",
"bytes",
")",
"->",
"None",
":",
"if",
"size",
":",
"validate_uint256",
"(",
"start_position",
")",
"validate_uint256",
"(",
"size",
")",
"validat... | Write `value` into memory. | [
"Write",
"value",
"into",
"memory",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/memory.py#L49-L61 |
243,964 | ethereum/py-evm | eth/vm/memory.py | Memory.read | def read(self, start_position: int, size: int) -> memoryview:
"""
Return a view into the memory
"""
return memoryview(self._bytes)[start_position:start_position + size] | python | def read(self, start_position: int, size: int) -> memoryview:
return memoryview(self._bytes)[start_position:start_position + size] | [
"def",
"read",
"(",
"self",
",",
"start_position",
":",
"int",
",",
"size",
":",
"int",
")",
"->",
"memoryview",
":",
"return",
"memoryview",
"(",
"self",
".",
"_bytes",
")",
"[",
"start_position",
":",
"start_position",
"+",
"size",
"]"
] | Return a view into the memory | [
"Return",
"a",
"view",
"into",
"the",
"memory"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/memory.py#L63-L67 |
243,965 | ethereum/py-evm | eth/vm/memory.py | Memory.read_bytes | def read_bytes(self, start_position: int, size: int) -> bytes:
"""
Read a value from memory and return a fresh bytes instance
"""
return bytes(self._bytes[start_position:start_position + size]) | python | def read_bytes(self, start_position: int, size: int) -> bytes:
return bytes(self._bytes[start_position:start_position + size]) | [
"def",
"read_bytes",
"(",
"self",
",",
"start_position",
":",
"int",
",",
"size",
":",
"int",
")",
"->",
"bytes",
":",
"return",
"bytes",
"(",
"self",
".",
"_bytes",
"[",
"start_position",
":",
"start_position",
"+",
"size",
"]",
")"
] | Read a value from memory and return a fresh bytes instance | [
"Read",
"a",
"value",
"from",
"memory",
"and",
"return",
"a",
"fresh",
"bytes",
"instance"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/memory.py#L69-L73 |
243,966 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.extend_memory | def extend_memory(self, start_position: int, size: int) -> None:
"""
Extend the size of the memory to be at minimum ``start_position + size``
bytes in length. Raise `eth.exceptions.OutOfGas` if there is not enough
gas to pay for extending the memory.
"""
validate_uint256... | python | def extend_memory(self, start_position: int, size: int) -> None:
validate_uint256(start_position, title="Memory start position")
validate_uint256(size, title="Memory size")
before_size = ceil32(len(self._memory))
after_size = ceil32(start_position + size)
before_cost = memory_g... | [
"def",
"extend_memory",
"(",
"self",
",",
"start_position",
":",
"int",
",",
"size",
":",
"int",
")",
"->",
"None",
":",
"validate_uint256",
"(",
"start_position",
",",
"title",
"=",
"\"Memory start position\"",
")",
"validate_uint256",
"(",
"size",
",",
"titl... | Extend the size of the memory to be at minimum ``start_position + size``
bytes in length. Raise `eth.exceptions.OutOfGas` if there is not enough
gas to pay for extending the memory. | [
"Extend",
"the",
"size",
"of",
"the",
"memory",
"to",
"be",
"at",
"minimum",
"start_position",
"+",
"size",
"bytes",
"in",
"length",
".",
"Raise",
"eth",
".",
"exceptions",
".",
"OutOfGas",
"if",
"there",
"is",
"not",
"enough",
"gas",
"to",
"pay",
"for",... | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L205-L242 |
243,967 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.memory_read | def memory_read(self, start_position: int, size: int) -> memoryview:
"""
Read and return a view of ``size`` bytes from memory starting at ``start_position``.
"""
return self._memory.read(start_position, size) | python | def memory_read(self, start_position: int, size: int) -> memoryview:
return self._memory.read(start_position, size) | [
"def",
"memory_read",
"(",
"self",
",",
"start_position",
":",
"int",
",",
"size",
":",
"int",
")",
"->",
"memoryview",
":",
"return",
"self",
".",
"_memory",
".",
"read",
"(",
"start_position",
",",
"size",
")"
] | Read and return a view of ``size`` bytes from memory starting at ``start_position``. | [
"Read",
"and",
"return",
"a",
"view",
"of",
"size",
"bytes",
"from",
"memory",
"starting",
"at",
"start_position",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L250-L254 |
243,968 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.memory_read_bytes | def memory_read_bytes(self, start_position: int, size: int) -> bytes:
"""
Read and return ``size`` bytes from memory starting at ``start_position``.
"""
return self._memory.read_bytes(start_position, size) | python | def memory_read_bytes(self, start_position: int, size: int) -> bytes:
return self._memory.read_bytes(start_position, size) | [
"def",
"memory_read_bytes",
"(",
"self",
",",
"start_position",
":",
"int",
",",
"size",
":",
"int",
")",
"->",
"bytes",
":",
"return",
"self",
".",
"_memory",
".",
"read_bytes",
"(",
"start_position",
",",
"size",
")"
] | Read and return ``size`` bytes from memory starting at ``start_position``. | [
"Read",
"and",
"return",
"size",
"bytes",
"from",
"memory",
"starting",
"at",
"start_position",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L256-L260 |
243,969 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.consume_gas | def consume_gas(self, amount: int, reason: str) -> None:
"""
Consume ``amount`` of gas from the remaining gas.
Raise `eth.exceptions.OutOfGas` if there is not enough gas remaining.
"""
return self._gas_meter.consume_gas(amount, reason) | python | def consume_gas(self, amount: int, reason: str) -> None:
return self._gas_meter.consume_gas(amount, reason) | [
"def",
"consume_gas",
"(",
"self",
",",
"amount",
":",
"int",
",",
"reason",
":",
"str",
")",
"->",
"None",
":",
"return",
"self",
".",
"_gas_meter",
".",
"consume_gas",
"(",
"amount",
",",
"reason",
")"
] | Consume ``amount`` of gas from the remaining gas.
Raise `eth.exceptions.OutOfGas` if there is not enough gas remaining. | [
"Consume",
"amount",
"of",
"gas",
"from",
"the",
"remaining",
"gas",
".",
"Raise",
"eth",
".",
"exceptions",
".",
"OutOfGas",
"if",
"there",
"is",
"not",
"enough",
"gas",
"remaining",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L268-L273 |
243,970 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.stack_pop | def stack_pop(self, num_items: int=1, type_hint: str=None) -> Any:
# TODO: Needs to be replaced with
# `Union[int, bytes, Tuple[Union[int, bytes], ...]]` if done properly
"""
Pop and return a number of items equal to ``num_items`` from the stack.
``type_hint`` can be either ``'ui... | python | def stack_pop(self, num_items: int=1, type_hint: str=None) -> Any:
# TODO: Needs to be replaced with
# `Union[int, bytes, Tuple[Union[int, bytes], ...]]` if done properly
return self._stack.pop(num_items, type_hint) | [
"def",
"stack_pop",
"(",
"self",
",",
"num_items",
":",
"int",
"=",
"1",
",",
"type_hint",
":",
"str",
"=",
"None",
")",
"->",
"Any",
":",
"# TODO: Needs to be replaced with",
"# `Union[int, bytes, Tuple[Union[int, bytes], ...]]` if done properly",
"return",
"self",
"... | Pop and return a number of items equal to ``num_items`` from the stack.
``type_hint`` can be either ``'uint256'`` or ``'bytes'``. The return value
will be an ``int`` or ``bytes`` type depending on the value provided for
the ``type_hint``.
Raise `eth.exceptions.InsufficientStack` if the... | [
"Pop",
"and",
"return",
"a",
"number",
"of",
"items",
"equal",
"to",
"num_items",
"from",
"the",
"stack",
".",
"type_hint",
"can",
"be",
"either",
"uint256",
"or",
"bytes",
".",
"The",
"return",
"value",
"will",
"be",
"an",
"int",
"or",
"bytes",
"type",
... | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L311-L323 |
243,971 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.stack_push | def stack_push(self, value: Union[int, bytes]) -> None:
"""
Push ``value`` onto the stack.
Raise `eth.exceptions.StackDepthLimit` if the stack is full.
"""
return self._stack.push(value) | python | def stack_push(self, value: Union[int, bytes]) -> None:
return self._stack.push(value) | [
"def",
"stack_push",
"(",
"self",
",",
"value",
":",
"Union",
"[",
"int",
",",
"bytes",
"]",
")",
"->",
"None",
":",
"return",
"self",
".",
"_stack",
".",
"push",
"(",
"value",
")"
] | Push ``value`` onto the stack.
Raise `eth.exceptions.StackDepthLimit` if the stack is full. | [
"Push",
"value",
"onto",
"the",
"stack",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L325-L331 |
243,972 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.prepare_child_message | def prepare_child_message(self,
gas: int,
to: Address,
value: int,
data: BytesOrView,
code: bytes,
**kwargs: Any) -> Message:
"""
... | python | def prepare_child_message(self,
gas: int,
to: Address,
value: int,
data: BytesOrView,
code: bytes,
**kwargs: Any) -> Message:
kwargs... | [
"def",
"prepare_child_message",
"(",
"self",
",",
"gas",
":",
"int",
",",
"to",
":",
"Address",
",",
"value",
":",
"int",
",",
"data",
":",
"BytesOrView",
",",
"code",
":",
"bytes",
",",
"*",
"*",
"kwargs",
":",
"Any",
")",
"->",
"Message",
":",
"k... | Helper method for creating a child computation. | [
"Helper",
"method",
"for",
"creating",
"a",
"child",
"computation",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L369-L390 |
243,973 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.apply_child_computation | def apply_child_computation(self, child_msg: Message) -> 'BaseComputation':
"""
Apply the vm message ``child_msg`` as a child computation.
"""
child_computation = self.generate_child_computation(child_msg)
self.add_child_computation(child_computation)
return child_computa... | python | def apply_child_computation(self, child_msg: Message) -> 'BaseComputation':
child_computation = self.generate_child_computation(child_msg)
self.add_child_computation(child_computation)
return child_computation | [
"def",
"apply_child_computation",
"(",
"self",
",",
"child_msg",
":",
"Message",
")",
"->",
"'BaseComputation'",
":",
"child_computation",
"=",
"self",
".",
"generate_child_computation",
"(",
"child_msg",
")",
"self",
".",
"add_child_computation",
"(",
"child_computat... | Apply the vm message ``child_msg`` as a child computation. | [
"Apply",
"the",
"vm",
"message",
"child_msg",
"as",
"a",
"child",
"computation",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L392-L398 |
243,974 | ethereum/py-evm | eth/vm/computation.py | BaseComputation._get_log_entries | def _get_log_entries(self) -> List[Tuple[int, bytes, List[int], bytes]]:
"""
Return the log entries for this computation and its children.
They are sorted in the same order they were emitted during the transaction processing, and
include the sequential counter as the first element of th... | python | def _get_log_entries(self) -> List[Tuple[int, bytes, List[int], bytes]]:
if self.is_error:
return []
else:
return sorted(itertools.chain(
self._log_entries,
*(child._get_log_entries() for child in self.children)
)) | [
"def",
"_get_log_entries",
"(",
"self",
")",
"->",
"List",
"[",
"Tuple",
"[",
"int",
",",
"bytes",
",",
"List",
"[",
"int",
"]",
",",
"bytes",
"]",
"]",
":",
"if",
"self",
".",
"is_error",
":",
"return",
"[",
"]",
"else",
":",
"return",
"sorted",
... | Return the log entries for this computation and its children.
They are sorted in the same order they were emitted during the transaction processing, and
include the sequential counter as the first element of the tuple representing every entry. | [
"Return",
"the",
"log",
"entries",
"for",
"this",
"computation",
"and",
"its",
"children",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L463-L476 |
243,975 | ethereum/py-evm | eth/vm/computation.py | BaseComputation.apply_computation | def apply_computation(cls,
state: BaseState,
message: Message,
transaction_context: BaseTransactionContext) -> 'BaseComputation':
"""
Perform the computation that would be triggered by the VM message.
"""
with ... | python | def apply_computation(cls,
state: BaseState,
message: Message,
transaction_context: BaseTransactionContext) -> 'BaseComputation':
with cls(state, message, transaction_context) as computation:
# Early exit on pre-compiles
... | [
"def",
"apply_computation",
"(",
"cls",
",",
"state",
":",
"BaseState",
",",
"message",
":",
"Message",
",",
"transaction_context",
":",
"BaseTransactionContext",
")",
"->",
"'BaseComputation'",
":",
"with",
"cls",
"(",
"state",
",",
"message",
",",
"transaction... | Perform the computation that would be triggered by the VM message. | [
"Perform",
"the",
"computation",
"that",
"would",
"be",
"triggered",
"by",
"the",
"VM",
"message",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/computation.py#L562-L592 |
243,976 | ethereum/py-evm | eth/vm/forks/homestead/headers.py | compute_homestead_difficulty | def compute_homestead_difficulty(parent_header: BlockHeader, timestamp: int) -> int:
"""
Computes the difficulty for a homestead block based on the parent block.
"""
parent_tstamp = parent_header.timestamp
validate_gt(timestamp, parent_tstamp, title="Header.timestamp")
offset = parent_header.dif... | python | def compute_homestead_difficulty(parent_header: BlockHeader, timestamp: int) -> int:
parent_tstamp = parent_header.timestamp
validate_gt(timestamp, parent_tstamp, title="Header.timestamp")
offset = parent_header.difficulty // DIFFICULTY_ADJUSTMENT_DENOMINATOR
sign = max(
1 - (timestamp - parent_... | [
"def",
"compute_homestead_difficulty",
"(",
"parent_header",
":",
"BlockHeader",
",",
"timestamp",
":",
"int",
")",
"->",
"int",
":",
"parent_tstamp",
"=",
"parent_header",
".",
"timestamp",
"validate_gt",
"(",
"timestamp",
",",
"parent_tstamp",
",",
"title",
"=",... | Computes the difficulty for a homestead block based on the parent block. | [
"Computes",
"the",
"difficulty",
"for",
"a",
"homestead",
"block",
"based",
"on",
"the",
"parent",
"block",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/forks/homestead/headers.py#L39-L58 |
243,977 | ethereum/py-evm | eth/vm/state.py | BaseState.snapshot | def snapshot(self) -> Tuple[Hash32, UUID]:
"""
Perform a full snapshot of the current state.
Snapshots are a combination of the :attr:`~state_root` at the time of the
snapshot and the id of the changeset from the journaled DB.
"""
return self.state_root, self._account_db... | python | def snapshot(self) -> Tuple[Hash32, UUID]:
return self.state_root, self._account_db.record() | [
"def",
"snapshot",
"(",
"self",
")",
"->",
"Tuple",
"[",
"Hash32",
",",
"UUID",
"]",
":",
"return",
"self",
".",
"state_root",
",",
"self",
".",
"_account_db",
".",
"record",
"(",
")"
] | Perform a full snapshot of the current state.
Snapshots are a combination of the :attr:`~state_root` at the time of the
snapshot and the id of the changeset from the journaled DB. | [
"Perform",
"a",
"full",
"snapshot",
"of",
"the",
"current",
"state",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/state.py#L225-L232 |
243,978 | ethereum/py-evm | eth/vm/state.py | BaseState.revert | def revert(self, snapshot: Tuple[Hash32, UUID]) -> None:
"""
Revert the VM to the state at the snapshot
"""
state_root, account_snapshot = snapshot
# first revert the database state root.
self._account_db.state_root = state_root
# now roll the underlying database... | python | def revert(self, snapshot: Tuple[Hash32, UUID]) -> None:
state_root, account_snapshot = snapshot
# first revert the database state root.
self._account_db.state_root = state_root
# now roll the underlying database back
self._account_db.discard(account_snapshot) | [
"def",
"revert",
"(",
"self",
",",
"snapshot",
":",
"Tuple",
"[",
"Hash32",
",",
"UUID",
"]",
")",
"->",
"None",
":",
"state_root",
",",
"account_snapshot",
"=",
"snapshot",
"# first revert the database state root.",
"self",
".",
"_account_db",
".",
"state_root"... | Revert the VM to the state at the snapshot | [
"Revert",
"the",
"VM",
"to",
"the",
"state",
"at",
"the",
"snapshot"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/state.py#L234-L243 |
243,979 | ethereum/py-evm | eth/vm/state.py | BaseState.get_computation | def get_computation(self,
message: Message,
transaction_context: 'BaseTransactionContext') -> 'BaseComputation':
"""
Return a computation instance for the given `message` and `transaction_context`
"""
if self.computation_class is None:
... | python | def get_computation(self,
message: Message,
transaction_context: 'BaseTransactionContext') -> 'BaseComputation':
if self.computation_class is None:
raise AttributeError("No `computation_class` has been set for this State")
else:
com... | [
"def",
"get_computation",
"(",
"self",
",",
"message",
":",
"Message",
",",
"transaction_context",
":",
"'BaseTransactionContext'",
")",
"->",
"'BaseComputation'",
":",
"if",
"self",
".",
"computation_class",
"is",
"None",
":",
"raise",
"AttributeError",
"(",
"\"N... | Return a computation instance for the given `message` and `transaction_context` | [
"Return",
"a",
"computation",
"instance",
"for",
"the",
"given",
"message",
"and",
"transaction_context"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/state.py#L283-L293 |
243,980 | ethereum/py-evm | eth/vm/state.py | BaseState.apply_transaction | def apply_transaction(
self,
transaction: BaseOrSpoofTransaction) -> 'BaseComputation':
"""
Apply transaction to the vm state
:param transaction: the transaction to apply
:return: the computation
"""
if self.state_root != BLANK_ROOT_HASH and not s... | python | def apply_transaction(
self,
transaction: BaseOrSpoofTransaction) -> 'BaseComputation':
if self.state_root != BLANK_ROOT_HASH and not self._account_db.has_root(self.state_root):
raise StateRootNotFound(self.state_root)
else:
return self.execute_transaction... | [
"def",
"apply_transaction",
"(",
"self",
",",
"transaction",
":",
"BaseOrSpoofTransaction",
")",
"->",
"'BaseComputation'",
":",
"if",
"self",
".",
"state_root",
"!=",
"BLANK_ROOT_HASH",
"and",
"not",
"self",
".",
"_account_db",
".",
"has_root",
"(",
"self",
"."... | Apply transaction to the vm state
:param transaction: the transaction to apply
:return: the computation | [
"Apply",
"transaction",
"to",
"the",
"vm",
"state"
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/state.py#L311-L323 |
243,981 | ethereum/py-evm | eth/_utils/env.py | get_env_value | def get_env_value(name: str, required: bool=False, default: Any=empty) -> str:
"""
Core function for extracting the environment variable.
Enforces mutual exclusivity between `required` and `default` keywords.
The `empty` sentinal value is used as the default `default` value to allow
other function... | python | def get_env_value(name: str, required: bool=False, default: Any=empty) -> str:
if required and default is not empty:
raise ValueError("Using `default` with `required=True` is invalid")
elif required:
try:
value = os.environ[name]
except KeyError:
raise KeyError(
... | [
"def",
"get_env_value",
"(",
"name",
":",
"str",
",",
"required",
":",
"bool",
"=",
"False",
",",
"default",
":",
"Any",
"=",
"empty",
")",
"->",
"str",
":",
"if",
"required",
"and",
"default",
"is",
"not",
"empty",
":",
"raise",
"ValueError",
"(",
"... | Core function for extracting the environment variable.
Enforces mutual exclusivity between `required` and `default` keywords.
The `empty` sentinal value is used as the default `default` value to allow
other function to handle default/empty logic in the appropriate way. | [
"Core",
"function",
"for",
"extracting",
"the",
"environment",
"variable",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/_utils/env.py#L36-L56 |
243,982 | ethereum/py-evm | eth/vm/base.py | BaseVM.make_receipt | def make_receipt(self,
base_header: BlockHeader,
transaction: BaseTransaction,
computation: BaseComputation,
state: BaseState) -> Receipt:
"""
Generate the receipt resulting from applying the transaction.
:param... | python | def make_receipt(self,
base_header: BlockHeader,
transaction: BaseTransaction,
computation: BaseComputation,
state: BaseState) -> Receipt:
raise NotImplementedError("VM classes must implement this method") | [
"def",
"make_receipt",
"(",
"self",
",",
"base_header",
":",
"BlockHeader",
",",
"transaction",
":",
"BaseTransaction",
",",
"computation",
":",
"BaseComputation",
",",
"state",
":",
"BaseState",
")",
"->",
"Receipt",
":",
"raise",
"NotImplementedError",
"(",
"\... | Generate the receipt resulting from applying the transaction.
:param base_header: the header of the block before the transaction was applied.
:param transaction: the transaction used to generate the receipt
:param computation: the result of running the transaction computation
:param sta... | [
"Generate",
"the",
"receipt",
"resulting",
"from",
"applying",
"the",
"transaction",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L155-L170 |
243,983 | ethereum/py-evm | eth/vm/base.py | VM.execute_bytecode | def execute_bytecode(self,
origin: Address,
gas_price: int,
gas: int,
to: Address,
sender: Address,
value: int,
data: bytes,
... | python | def execute_bytecode(self,
origin: Address,
gas_price: int,
gas: int,
to: Address,
sender: Address,
value: int,
data: bytes,
... | [
"def",
"execute_bytecode",
"(",
"self",
",",
"origin",
":",
"Address",
",",
"gas_price",
":",
"int",
",",
"gas",
":",
"int",
",",
"to",
":",
"Address",
",",
"sender",
":",
"Address",
",",
"value",
":",
"int",
",",
"data",
":",
"bytes",
",",
"code",
... | Execute raw bytecode in the context of the current state of
the virtual machine. | [
"Execute",
"raw",
"bytecode",
"in",
"the",
"context",
"of",
"the",
"current",
"state",
"of",
"the",
"virtual",
"machine",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L470-L510 |
243,984 | ethereum/py-evm | eth/vm/base.py | VM.import_block | def import_block(self, block: BaseBlock) -> BaseBlock:
"""
Import the given block to the chain.
"""
if self.block.number != block.number:
raise ValidationError(
"This VM can only import blocks at number #{}, the attempted block was #{}".format(
... | python | def import_block(self, block: BaseBlock) -> BaseBlock:
if self.block.number != block.number:
raise ValidationError(
"This VM can only import blocks at number #{}, the attempted block was #{}".format(
self.block.number,
block.number,
... | [
"def",
"import_block",
"(",
"self",
",",
"block",
":",
"BaseBlock",
")",
"->",
"BaseBlock",
":",
"if",
"self",
".",
"block",
".",
"number",
"!=",
"block",
".",
"number",
":",
"raise",
"ValidationError",
"(",
"\"This VM can only import blocks at number #{}, the att... | Import the given block to the chain. | [
"Import",
"the",
"given",
"block",
"to",
"the",
"chain",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L557-L594 |
243,985 | ethereum/py-evm | eth/vm/base.py | VM.mine_block | def mine_block(self, *args: Any, **kwargs: Any) -> BaseBlock:
"""
Mine the current block. Proxies to self.pack_block method.
"""
packed_block = self.pack_block(self.block, *args, **kwargs)
final_block = self.finalize_block(packed_block)
# Perform validation
self... | python | def mine_block(self, *args: Any, **kwargs: Any) -> BaseBlock:
packed_block = self.pack_block(self.block, *args, **kwargs)
final_block = self.finalize_block(packed_block)
# Perform validation
self.validate_block(final_block)
return final_block | [
"def",
"mine_block",
"(",
"self",
",",
"*",
"args",
":",
"Any",
",",
"*",
"*",
"kwargs",
":",
"Any",
")",
"->",
"BaseBlock",
":",
"packed_block",
"=",
"self",
".",
"pack_block",
"(",
"self",
".",
"block",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
... | Mine the current block. Proxies to self.pack_block method. | [
"Mine",
"the",
"current",
"block",
".",
"Proxies",
"to",
"self",
".",
"pack_block",
"method",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L596-L607 |
243,986 | ethereum/py-evm | eth/vm/base.py | VM.finalize_block | def finalize_block(self, block: BaseBlock) -> BaseBlock:
"""
Perform any finalization steps like awarding the block mining reward,
and persisting the final state root.
"""
if block.number > 0:
self._assign_block_rewards(block)
# We need to call `persist` here... | python | def finalize_block(self, block: BaseBlock) -> BaseBlock:
if block.number > 0:
self._assign_block_rewards(block)
# We need to call `persist` here since the state db batches
# all writes until we tell it to write to the underlying db
self.state.persist()
return block.... | [
"def",
"finalize_block",
"(",
"self",
",",
"block",
":",
"BaseBlock",
")",
"->",
"BaseBlock",
":",
"if",
"block",
".",
"number",
">",
"0",
":",
"self",
".",
"_assign_block_rewards",
"(",
"block",
")",
"# We need to call `persist` here since the state db batches",
... | Perform any finalization steps like awarding the block mining reward,
and persisting the final state root. | [
"Perform",
"any",
"finalization",
"steps",
"like",
"awarding",
"the",
"block",
"mining",
"reward",
"and",
"persisting",
"the",
"final",
"state",
"root",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L653-L665 |
243,987 | ethereum/py-evm | eth/vm/base.py | VM.pack_block | def pack_block(self, block: BaseBlock, *args: Any, **kwargs: Any) -> BaseBlock:
"""
Pack block for mining.
:param bytes coinbase: 20-byte public address to receive block reward
:param bytes uncles_hash: 32 bytes
:param bytes state_root: 32 bytes
:param bytes transaction_... | python | def pack_block(self, block: BaseBlock, *args: Any, **kwargs: Any) -> BaseBlock:
if 'uncles' in kwargs:
uncles = kwargs.pop('uncles')
kwargs.setdefault('uncles_hash', keccak(rlp.encode(uncles)))
else:
uncles = block.uncles
provided_fields = set(kwargs.keys())
... | [
"def",
"pack_block",
"(",
"self",
",",
"block",
":",
"BaseBlock",
",",
"*",
"args",
":",
"Any",
",",
"*",
"*",
"kwargs",
":",
"Any",
")",
"->",
"BaseBlock",
":",
"if",
"'uncles'",
"in",
"kwargs",
":",
"uncles",
"=",
"kwargs",
".",
"pop",
"(",
"'unc... | Pack block for mining.
:param bytes coinbase: 20-byte public address to receive block reward
:param bytes uncles_hash: 32 bytes
:param bytes state_root: 32 bytes
:param bytes transaction_root: 32 bytes
:param bytes receipt_root: 32 bytes
:param int bloom:
:param ... | [
"Pack",
"block",
"for",
"mining",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L667-L704 |
243,988 | ethereum/py-evm | eth/vm/base.py | VM.generate_block_from_parent_header_and_coinbase | def generate_block_from_parent_header_and_coinbase(cls,
parent_header: BlockHeader,
coinbase: Address) -> BaseBlock:
"""
Generate block from parent header and coinbase.
"""
block... | python | def generate_block_from_parent_header_and_coinbase(cls,
parent_header: BlockHeader,
coinbase: Address) -> BaseBlock:
block_header = generate_header_from_parent_header(
cls.compute_difficulty... | [
"def",
"generate_block_from_parent_header_and_coinbase",
"(",
"cls",
",",
"parent_header",
":",
"BlockHeader",
",",
"coinbase",
":",
"Address",
")",
"->",
"BaseBlock",
":",
"block_header",
"=",
"generate_header_from_parent_header",
"(",
"cls",
".",
"compute_difficulty",
... | Generate block from parent header and coinbase. | [
"Generate",
"block",
"from",
"parent",
"header",
"and",
"coinbase",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L710-L727 |
243,989 | ethereum/py-evm | eth/vm/base.py | VM.previous_hashes | def previous_hashes(self) -> Optional[Iterable[Hash32]]:
"""
Convenience API for accessing the previous 255 block hashes.
"""
return self.get_prev_hashes(self.header.parent_hash, self.chaindb) | python | def previous_hashes(self) -> Optional[Iterable[Hash32]]:
return self.get_prev_hashes(self.header.parent_hash, self.chaindb) | [
"def",
"previous_hashes",
"(",
"self",
")",
"->",
"Optional",
"[",
"Iterable",
"[",
"Hash32",
"]",
"]",
":",
"return",
"self",
".",
"get_prev_hashes",
"(",
"self",
".",
"header",
".",
"parent_hash",
",",
"self",
".",
"chaindb",
")"
] | Convenience API for accessing the previous 255 block hashes. | [
"Convenience",
"API",
"for",
"accessing",
"the",
"previous",
"255",
"block",
"hashes",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L756-L760 |
243,990 | ethereum/py-evm | eth/vm/base.py | VM.create_transaction | def create_transaction(self, *args: Any, **kwargs: Any) -> BaseTransaction:
"""
Proxy for instantiating a signed transaction for this VM.
"""
return self.get_transaction_class()(*args, **kwargs) | python | def create_transaction(self, *args: Any, **kwargs: Any) -> BaseTransaction:
return self.get_transaction_class()(*args, **kwargs) | [
"def",
"create_transaction",
"(",
"self",
",",
"*",
"args",
":",
"Any",
",",
"*",
"*",
"kwargs",
":",
"Any",
")",
"->",
"BaseTransaction",
":",
"return",
"self",
".",
"get_transaction_class",
"(",
")",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] | Proxy for instantiating a signed transaction for this VM. | [
"Proxy",
"for",
"instantiating",
"a",
"signed",
"transaction",
"for",
"this",
"VM",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L765-L769 |
243,991 | ethereum/py-evm | eth/vm/base.py | VM.create_unsigned_transaction | def create_unsigned_transaction(cls,
*,
nonce: int,
gas_price: int,
gas: int,
to: Address,
value: int,
... | python | def create_unsigned_transaction(cls,
*,
nonce: int,
gas_price: int,
gas: int,
to: Address,
value: int,
... | [
"def",
"create_unsigned_transaction",
"(",
"cls",
",",
"*",
",",
"nonce",
":",
"int",
",",
"gas_price",
":",
"int",
",",
"gas",
":",
"int",
",",
"to",
":",
"Address",
",",
"value",
":",
"int",
",",
"data",
":",
"bytes",
")",
"->",
"'BaseUnsignedTransac... | Proxy for instantiating an unsigned transaction for this VM. | [
"Proxy",
"for",
"instantiating",
"an",
"unsigned",
"transaction",
"for",
"this",
"VM",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L772-L790 |
243,992 | ethereum/py-evm | eth/vm/base.py | VM.validate_block | def validate_block(self, block: BaseBlock) -> None:
"""
Validate the the given block.
"""
if not isinstance(block, self.get_block_class()):
raise ValidationError(
"This vm ({0!r}) is not equipped to validate a block of type {1!r}".format(
s... | python | def validate_block(self, block: BaseBlock) -> None:
if not isinstance(block, self.get_block_class()):
raise ValidationError(
"This vm ({0!r}) is not equipped to validate a block of type {1!r}".format(
self,
block,
)
... | [
"def",
"validate_block",
"(",
"self",
",",
"block",
":",
"BaseBlock",
")",
"->",
"None",
":",
"if",
"not",
"isinstance",
"(",
"block",
",",
"self",
".",
"get_block_class",
"(",
")",
")",
":",
"raise",
"ValidationError",
"(",
"\"This vm ({0!r}) is not equipped ... | Validate the the given block. | [
"Validate",
"the",
"the",
"given",
"block",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L828-L876 |
243,993 | ethereum/py-evm | eth/vm/base.py | VM.validate_uncle | def validate_uncle(cls, block: BaseBlock, uncle: BaseBlock, uncle_parent: BaseBlock) -> None:
"""
Validate the given uncle in the context of the given block.
"""
if uncle.block_number >= block.number:
raise ValidationError(
"Uncle number ({0}) is higher than b... | python | def validate_uncle(cls, block: BaseBlock, uncle: BaseBlock, uncle_parent: BaseBlock) -> None:
if uncle.block_number >= block.number:
raise ValidationError(
"Uncle number ({0}) is higher than block number ({1})".format(
uncle.block_number, block.number))
i... | [
"def",
"validate_uncle",
"(",
"cls",
",",
"block",
":",
"BaseBlock",
",",
"uncle",
":",
"BaseBlock",
",",
"uncle_parent",
":",
"BaseBlock",
")",
"->",
"None",
":",
"if",
"uncle",
".",
"block_number",
">=",
"block",
".",
"number",
":",
"raise",
"ValidationE... | Validate the given uncle in the context of the given block. | [
"Validate",
"the",
"given",
"uncle",
"in",
"the",
"context",
"of",
"the",
"given",
"block",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/vm/base.py#L927-L947 |
243,994 | ethereum/py-evm | eth/tools/_utils/mappings.py | is_cleanly_mergable | def is_cleanly_mergable(*dicts: Dict[Any, Any]) -> bool:
"""Check that nothing will be overwritten when dictionaries are merged using `deep_merge`.
Examples:
>>> is_cleanly_mergable({"a": 1}, {"b": 2}, {"c": 3})
True
>>> is_cleanly_mergable({"a": 1}, {"b": 2}, {"a": 0, c": 3})
... | python | def is_cleanly_mergable(*dicts: Dict[Any, Any]) -> bool:
if len(dicts) <= 1:
return True
elif len(dicts) == 2:
if not all(isinstance(d, Mapping) for d in dicts):
return False
else:
shared_keys = set(dicts[0].keys()) & set(dicts[1].keys())
return all(is... | [
"def",
"is_cleanly_mergable",
"(",
"*",
"dicts",
":",
"Dict",
"[",
"Any",
",",
"Any",
"]",
")",
"->",
"bool",
":",
"if",
"len",
"(",
"dicts",
")",
"<=",
"1",
":",
"return",
"True",
"elif",
"len",
"(",
"dicts",
")",
"==",
"2",
":",
"if",
"not",
... | Check that nothing will be overwritten when dictionaries are merged using `deep_merge`.
Examples:
>>> is_cleanly_mergable({"a": 1}, {"b": 2}, {"c": 3})
True
>>> is_cleanly_mergable({"a": 1}, {"b": 2}, {"a": 0, c": 3})
False
>>> is_cleanly_mergable({"a": 1, "b": {"ba": 2}}, ... | [
"Check",
"that",
"nothing",
"will",
"be",
"overwritten",
"when",
"dictionaries",
"are",
"merged",
"using",
"deep_merge",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/_utils/mappings.py#L24-L49 |
243,995 | ethereum/py-evm | eth/db/diff.py | DBDiff.deleted_keys | def deleted_keys(self) -> Iterable[bytes]:
"""
List all the keys that have been deleted.
"""
for key, value in self._changes.items():
if value is DELETED:
yield key | python | def deleted_keys(self) -> Iterable[bytes]:
for key, value in self._changes.items():
if value is DELETED:
yield key | [
"def",
"deleted_keys",
"(",
"self",
")",
"->",
"Iterable",
"[",
"bytes",
"]",
":",
"for",
"key",
",",
"value",
"in",
"self",
".",
"_changes",
".",
"items",
"(",
")",
":",
"if",
"value",
"is",
"DELETED",
":",
"yield",
"key"
] | List all the keys that have been deleted. | [
"List",
"all",
"the",
"keys",
"that",
"have",
"been",
"deleted",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/diff.py#L160-L166 |
243,996 | ethereum/py-evm | eth/db/diff.py | DBDiff.apply_to | def apply_to(self,
db: Union[BaseDB, ABC_Mutable_Mapping],
apply_deletes: bool = True) -> None:
"""
Apply the changes in this diff to the given database.
You may choose to opt out of deleting any underlying keys.
:param apply_deletes: whether the pendin... | python | def apply_to(self,
db: Union[BaseDB, ABC_Mutable_Mapping],
apply_deletes: bool = True) -> None:
for key, value in self._changes.items():
if value is DELETED:
if apply_deletes:
try:
del db[key]
... | [
"def",
"apply_to",
"(",
"self",
",",
"db",
":",
"Union",
"[",
"BaseDB",
",",
"ABC_Mutable_Mapping",
"]",
",",
"apply_deletes",
":",
"bool",
"=",
"True",
")",
"->",
"None",
":",
"for",
"key",
",",
"value",
"in",
"self",
".",
"_changes",
".",
"items",
... | Apply the changes in this diff to the given database.
You may choose to opt out of deleting any underlying keys.
:param apply_deletes: whether the pending deletes should be
applied to the database | [
"Apply",
"the",
"changes",
"in",
"this",
"diff",
"to",
"the",
"given",
"database",
".",
"You",
"may",
"choose",
"to",
"opt",
"out",
"of",
"deleting",
"any",
"underlying",
"keys",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/diff.py#L188-L208 |
243,997 | ethereum/py-evm | eth/db/diff.py | DBDiff.join | def join(cls, diffs: Iterable['DBDiff']) -> 'DBDiff':
"""
Join several DBDiff objects into a single DBDiff object.
In case of a conflict, changes in diffs that come later
in ``diffs`` will overwrite changes from earlier changes.
"""
tracker = DBDiffTracker()
for ... | python | def join(cls, diffs: Iterable['DBDiff']) -> 'DBDiff':
tracker = DBDiffTracker()
for diff in diffs:
diff.apply_to(tracker)
return tracker.diff() | [
"def",
"join",
"(",
"cls",
",",
"diffs",
":",
"Iterable",
"[",
"'DBDiff'",
"]",
")",
"->",
"'DBDiff'",
":",
"tracker",
"=",
"DBDiffTracker",
"(",
")",
"for",
"diff",
"in",
"diffs",
":",
"diff",
".",
"apply_to",
"(",
"tracker",
")",
"return",
"tracker",... | Join several DBDiff objects into a single DBDiff object.
In case of a conflict, changes in diffs that come later
in ``diffs`` will overwrite changes from earlier changes. | [
"Join",
"several",
"DBDiff",
"objects",
"into",
"a",
"single",
"DBDiff",
"object",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/db/diff.py#L211-L221 |
243,998 | ethereum/py-evm | eth/tools/_utils/hashing.py | hash_log_entries | def hash_log_entries(log_entries: Iterable[Tuple[bytes, List[int], bytes]]) -> Hash32:
"""
Helper function for computing the RLP hash of the logs from transaction
execution.
"""
logs = [Log(*entry) for entry in log_entries]
encoded_logs = rlp.encode(logs)
logs_hash = keccak(encoded_logs)
... | python | def hash_log_entries(log_entries: Iterable[Tuple[bytes, List[int], bytes]]) -> Hash32:
logs = [Log(*entry) for entry in log_entries]
encoded_logs = rlp.encode(logs)
logs_hash = keccak(encoded_logs)
return logs_hash | [
"def",
"hash_log_entries",
"(",
"log_entries",
":",
"Iterable",
"[",
"Tuple",
"[",
"bytes",
",",
"List",
"[",
"int",
"]",
",",
"bytes",
"]",
"]",
")",
"->",
"Hash32",
":",
"logs",
"=",
"[",
"Log",
"(",
"*",
"entry",
")",
"for",
"entry",
"in",
"log_... | Helper function for computing the RLP hash of the logs from transaction
execution. | [
"Helper",
"function",
"for",
"computing",
"the",
"RLP",
"hash",
"of",
"the",
"logs",
"from",
"transaction",
"execution",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/tools/_utils/hashing.py#L18-L26 |
243,999 | ethereum/py-evm | eth/chains/base.py | BaseChain.get_vm_class_for_block_number | def get_vm_class_for_block_number(cls, block_number: BlockNumber) -> Type['BaseVM']:
"""
Returns the VM class for the given block number.
"""
if cls.vm_configuration is None:
raise AttributeError("Chain classes must define the VMs in vm_configuration")
validate_block... | python | def get_vm_class_for_block_number(cls, block_number: BlockNumber) -> Type['BaseVM']:
if cls.vm_configuration is None:
raise AttributeError("Chain classes must define the VMs in vm_configuration")
validate_block_number(block_number)
for start_block, vm_class in reversed(cls.vm_config... | [
"def",
"get_vm_class_for_block_number",
"(",
"cls",
",",
"block_number",
":",
"BlockNumber",
")",
"->",
"Type",
"[",
"'BaseVM'",
"]",
":",
"if",
"cls",
".",
"vm_configuration",
"is",
"None",
":",
"raise",
"AttributeError",
"(",
"\"Chain classes must define the VMs i... | Returns the VM class for the given block number. | [
"Returns",
"the",
"VM",
"class",
"for",
"the",
"given",
"block",
"number",
"."
] | 58346848f076116381d3274bbcea96b9e2cfcbdf | https://github.com/ethereum/py-evm/blob/58346848f076116381d3274bbcea96b9e2cfcbdf/eth/chains/base.py#L182-L194 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.