body_hash
stringlengths 64
64
| body
stringlengths 23
109k
| docstring
stringlengths 1
57k
| path
stringlengths 4
198
| name
stringlengths 1
115
| repository_name
stringlengths 7
111
| repository_stars
float64 0
191k
| lang
stringclasses 1
value | body_without_docstring
stringlengths 14
108k
| unified
stringlengths 45
133k
|
|---|---|---|---|---|---|---|---|---|---|
11d4f9b449306eaf388ea7867de46d23b67cc54826ff61b156b8775f61102218 | def estimate_gas(self, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, tx_params: Optional[TxParams]=None) -> int:
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict()) | def estimate_gas(self, tx_params: Optional[TxParams]=None) -> int:
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
aece71b70dbc3a60060af1466c0d87fe4cf1a8567f7641a09c7c5fe8e50a1c58 | def validate_and_normalize_inputs(self, token_id: int):
'Validate the inputs to the ownerOf method.'
self.validator.assert_valid(method_name='ownerOf', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return token_id | Validate the inputs to the ownerOf method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, token_id: int):
self.validator.assert_valid(method_name='ownerOf', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return token_id | def validate_and_normalize_inputs(self, token_id: int):
self.validator.assert_valid(method_name='ownerOf', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return token_id<|docstring|>Validate the inputs to the ownerOf method.<|endoftext|> |
b4ffa91a77acf497f87845e803e7008e5aac6ef4505645f6d2a013bf16ca4e81 | def call(self, token_id: int, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id).call(tx_params.as_dict())
return str(returned) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, token_id: int, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id).call(tx_params.as_dict())
return str(returned) | def call(self, token_id: int, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id).call(tx_params.as_dict())
return str(returned)<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
e27f80815f34ab833e17016d58c78e88a1e64dce6c8824207fba04df6aa3d88e | def send_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).transact(tx_params.as_dict()) | def send_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
687dfac0950732365c580176289be1f67bed0b6a35eea8671dbe2d8d8c5059ec | def build_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).buildTransaction(tx_params.as_dict()) | def build_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
97cb33886d64af0a51559709537b845f521d6110be3b37d16b1d9830eccf83f5 | def estimate_gas(self, token_id: int, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, token_id: int, tx_params: Optional[TxParams]=None) -> int:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).estimateGas(tx_params.as_dict()) | def estimate_gas(self, token_id: int, tx_params: Optional[TxParams]=None) -> int:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
acf7b79d81e2c00b76a56f41e7ef2d5c615bb45a8117bf3a076a19b6c0738187 | def validate_and_normalize_inputs(self, role: Union[(bytes, str)], account: str):
'Validate the inputs to the renounceRole method.'
self.validator.assert_valid(method_name='renounceRole', parameter_name='role', argument_value=role)
self.validator.assert_valid(method_name='renounceRole', parameter_name='account', argument_value=account)
account = self.validate_and_checksum_address(account)
return (role, account) | Validate the inputs to the renounceRole method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, role: Union[(bytes, str)], account: str):
self.validator.assert_valid(method_name='renounceRole', parameter_name='role', argument_value=role)
self.validator.assert_valid(method_name='renounceRole', parameter_name='account', argument_value=account)
account = self.validate_and_checksum_address(account)
return (role, account) | def validate_and_normalize_inputs(self, role: Union[(bytes, str)], account: str):
self.validator.assert_valid(method_name='renounceRole', parameter_name='role', argument_value=role)
self.validator.assert_valid(method_name='renounceRole', parameter_name='account', argument_value=account)
account = self.validate_and_checksum_address(account)
return (role, account)<|docstring|>Validate the inputs to the renounceRole method.<|endoftext|> |
c4d9db112692cb5fb10a36a80b40e04be8f2ed29b834903d93ecfa91ad6d9eaa | def call(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(role, account).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(role, account).call(tx_params.as_dict()) | def call(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(role, account).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
b8d23a1f7656cf499417808f9816db13ec9c51752e526f9f9adbe6051d91de6d | def send_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).transact(tx_params.as_dict()) | def send_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
0503017ec0e8b6356d518ee7da3c9e8ce5c90f09f6713bddac26862095b3c454 | def build_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> dict:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).buildTransaction(tx_params.as_dict()) | def build_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> dict:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
b0e3e1536e50aa635ad61b23ac869a36eae01e5c6eb65f3d0d9d74fb83fce71d | def estimate_gas(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> int:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).estimateGas(tx_params.as_dict()) | def estimate_gas(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> int:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
70883204d899630c76a02b472e687bc63c0f03f1de6a5a45222503157325e946 | def validate_and_normalize_inputs(self, role: Union[(bytes, str)], account: str):
'Validate the inputs to the revokeRole method.'
self.validator.assert_valid(method_name='revokeRole', parameter_name='role', argument_value=role)
self.validator.assert_valid(method_name='revokeRole', parameter_name='account', argument_value=account)
account = self.validate_and_checksum_address(account)
return (role, account) | Validate the inputs to the revokeRole method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, role: Union[(bytes, str)], account: str):
self.validator.assert_valid(method_name='revokeRole', parameter_name='role', argument_value=role)
self.validator.assert_valid(method_name='revokeRole', parameter_name='account', argument_value=account)
account = self.validate_and_checksum_address(account)
return (role, account) | def validate_and_normalize_inputs(self, role: Union[(bytes, str)], account: str):
self.validator.assert_valid(method_name='revokeRole', parameter_name='role', argument_value=role)
self.validator.assert_valid(method_name='revokeRole', parameter_name='account', argument_value=account)
account = self.validate_and_checksum_address(account)
return (role, account)<|docstring|>Validate the inputs to the revokeRole method.<|endoftext|> |
c4d9db112692cb5fb10a36a80b40e04be8f2ed29b834903d93ecfa91ad6d9eaa | def call(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(role, account).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(role, account).call(tx_params.as_dict()) | def call(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(role, account).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
b8d23a1f7656cf499417808f9816db13ec9c51752e526f9f9adbe6051d91de6d | def send_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).transact(tx_params.as_dict()) | def send_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
0503017ec0e8b6356d518ee7da3c9e8ce5c90f09f6713bddac26862095b3c454 | def build_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> dict:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).buildTransaction(tx_params.as_dict()) | def build_transaction(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> dict:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
b0e3e1536e50aa635ad61b23ac869a36eae01e5c6eb65f3d0d9d74fb83fce71d | def estimate_gas(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> int:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).estimateGas(tx_params.as_dict()) | def estimate_gas(self, role: Union[(bytes, str)], account: str, tx_params: Optional[TxParams]=None) -> int:
(role, account) = self.validate_and_normalize_inputs(role, account)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(role, account).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
453f489d20f45ac705b216eac1133ff13d43c2ed10471646110148aea09ba531 | def validate_and_normalize_inputs(self, token_id: int, sale_price: int):
'Validate the inputs to the royaltyInfo method.'
self.validator.assert_valid(method_name='royaltyInfo', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='royaltyInfo', parameter_name='salePrice', argument_value=sale_price)
sale_price = int(sale_price)
return (token_id, sale_price) | Validate the inputs to the royaltyInfo method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, token_id: int, sale_price: int):
self.validator.assert_valid(method_name='royaltyInfo', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='royaltyInfo', parameter_name='salePrice', argument_value=sale_price)
sale_price = int(sale_price)
return (token_id, sale_price) | def validate_and_normalize_inputs(self, token_id: int, sale_price: int):
self.validator.assert_valid(method_name='royaltyInfo', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='royaltyInfo', parameter_name='salePrice', argument_value=sale_price)
sale_price = int(sale_price)
return (token_id, sale_price)<|docstring|>Validate the inputs to the royaltyInfo method.<|endoftext|> |
28f2397eb8f3d14afb62bdf7d656861c277cb9ebb7bf9b94e95e92a6214d3042 | def call(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> Tuple[(str, int)]:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id, sale_price).call(tx_params.as_dict())
return (returned[0], returned[1]) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> Tuple[(str, int)]:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id, sale_price).call(tx_params.as_dict())
return (returned[0], returned[1]) | def call(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> Tuple[(str, int)]:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id, sale_price).call(tx_params.as_dict())
return (returned[0], returned[1])<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
ca81b902cb0904d2f12f6d0ae4f580cce0399361e44362772c67651e354ef1c3 | def send_transaction(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).transact(tx_params.as_dict()) | def send_transaction(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
ebc713641fe13c5aaea4820e45eba2b703cc228a766c4a28c97117f9f5aadf5d | def build_transaction(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> dict:
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).buildTransaction(tx_params.as_dict()) | def build_transaction(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> dict:
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
703ab2a73c047c8583480ebb514fd6689cef1bc292ff7b83a69da981e12905f6 | def estimate_gas(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> int:
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).estimateGas(tx_params.as_dict()) | def estimate_gas(self, token_id: int, sale_price: int, tx_params: Optional[TxParams]=None) -> int:
(token_id, sale_price) = self.validate_and_normalize_inputs(token_id, sale_price)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, sale_price).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
07968553e1ba63affd3486e80fd7d7d74076c88a7ef3330ba14e1a42778b8c16 | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int):
'Validate the inputs to the safeTransferFrom method.'
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return (_from, to, token_id) | Validate the inputs to the safeTransferFrom method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int):
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return (_from, to, token_id) | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int):
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return (_from, to, token_id)<|docstring|>Validate the inputs to the safeTransferFrom method.<|endoftext|> |
55f5c0e01056ee361079040bd3db6271919a8c2068e4f3154b6fb1223d7014c1 | def call(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id).call(tx_params.as_dict()) | def call(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
12f9716ee47d8eecc462eec7da1667449a8dcb834ceed990ff804a240a75f666 | def send_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).transact(tx_params.as_dict()) | def send_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
9533a1b6781c6eca4a1d4a4b5041ac3039ab3a92a9cda59defaf68a11d9b2790 | def build_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).buildTransaction(tx_params.as_dict()) | def build_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
633806efea644a8125ef3cef45e3982fbea77d7f7afcde5641c8785c9cad2cb5 | def estimate_gas(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> int:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).estimateGas(tx_params.as_dict()) | def estimate_gas(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> int:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
005475d7f6288d28ef07610ab7e9c61c4184e704b03ef2cfe0cc1d75e14fbf41 | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)]):
'Validate the inputs to the safeTransferFrom method.'
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='_data', argument_value=data)
return (_from, to, token_id, data) | Validate the inputs to the safeTransferFrom method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)]):
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='_data', argument_value=data)
return (_from, to, token_id, data) | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)]):
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='safeTransferFrom', parameter_name='_data', argument_value=data)
return (_from, to, token_id, data)<|docstring|>Validate the inputs to the safeTransferFrom method.<|endoftext|> |
06c827c2e294efc75ce0f41a9b2272bdfbc097482bf6366f7220124c44076c99 | def call(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id, data).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id, data).call(tx_params.as_dict()) | def call(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id, data).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
292476f926ca51ed03fca7b9f6a9e87a134e9657fc3fdc0f8a8ded081d9dacf7 | def send_transaction(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).transact(tx_params.as_dict()) | def send_transaction(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
4d2067452674bfea5e5603a7fc424f80f2fd5b72a0a6efb7aae2e4af6c9d0c40 | def build_transaction(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> dict:
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).buildTransaction(tx_params.as_dict()) | def build_transaction(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> dict:
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
20deae960a95397f99fffa792576bb4144a6d935d7a10e36249f97212f5d145c | def estimate_gas(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> int:
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).estimateGas(tx_params.as_dict()) | def estimate_gas(self, _from: str, to: str, token_id: int, data: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> int:
(_from, to, token_id, data) = self.validate_and_normalize_inputs(_from, to, token_id, data)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id, data).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
e9cbe0f285c5735ba7f91b5c4bfe771122ee1c92b624f3a0860b48dcb78d4412 | def validate_and_normalize_inputs(self, operator: str, approved: bool):
'Validate the inputs to the setApprovalForAll method.'
self.validator.assert_valid(method_name='setApprovalForAll', parameter_name='operator', argument_value=operator)
operator = self.validate_and_checksum_address(operator)
self.validator.assert_valid(method_name='setApprovalForAll', parameter_name='approved', argument_value=approved)
return (operator, approved) | Validate the inputs to the setApprovalForAll method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, operator: str, approved: bool):
self.validator.assert_valid(method_name='setApprovalForAll', parameter_name='operator', argument_value=operator)
operator = self.validate_and_checksum_address(operator)
self.validator.assert_valid(method_name='setApprovalForAll', parameter_name='approved', argument_value=approved)
return (operator, approved) | def validate_and_normalize_inputs(self, operator: str, approved: bool):
self.validator.assert_valid(method_name='setApprovalForAll', parameter_name='operator', argument_value=operator)
operator = self.validate_and_checksum_address(operator)
self.validator.assert_valid(method_name='setApprovalForAll', parameter_name='approved', argument_value=approved)
return (operator, approved)<|docstring|>Validate the inputs to the setApprovalForAll method.<|endoftext|> |
a3ea062a9b6ae52c253db5c6bf08168a929e115aff5764e613669bffbb392250 | def call(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(operator, approved).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(operator, approved).call(tx_params.as_dict()) | def call(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(operator, approved).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
22d6810d62f5d111b74631f8fc99658b18b51ee94d7a74836a5fa5a86fd17cc3 | def send_transaction(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).transact(tx_params.as_dict()) | def send_transaction(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
68c816ea60955cc8e22d8e01abd3caa101da50716549d385741c882f425b54b8 | def build_transaction(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> dict:
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).buildTransaction(tx_params.as_dict()) | def build_transaction(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> dict:
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
613b1205d0189bda710c0ab34287f89579abc0685e33a2a6889b82c358a043a2 | def estimate_gas(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> int:
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).estimateGas(tx_params.as_dict()) | def estimate_gas(self, operator: str, approved: bool, tx_params: Optional[TxParams]=None) -> int:
(operator, approved) = self.validate_and_normalize_inputs(operator, approved)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(operator, approved).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
0aeec8359f589aa64a91fbac4eb5d6e1f05a807e46f0c3e98d2fc38d6fc99aeb | def validate_and_normalize_inputs(self, uri: str):
'Validate the inputs to the setContractURI method.'
self.validator.assert_valid(method_name='setContractURI', parameter_name='_uri', argument_value=uri)
return uri | Validate the inputs to the setContractURI method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, uri: str):
self.validator.assert_valid(method_name='setContractURI', parameter_name='_uri', argument_value=uri)
return uri | def validate_and_normalize_inputs(self, uri: str):
self.validator.assert_valid(method_name='setContractURI', parameter_name='_uri', argument_value=uri)
return uri<|docstring|>Validate the inputs to the setContractURI method.<|endoftext|> |
1c9556b0470858ecd41c77eb11bb453a6ef4aee00dd627704bc2db126eb38342 | def call(self, uri: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(uri).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, uri: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(uri).call(tx_params.as_dict()) | def call(self, uri: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(uri).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
c62133b15461f4562723e8b876f6d72a71b92959a37af9ebff831a6434c98a89 | def send_transaction(self, uri: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, uri: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).transact(tx_params.as_dict()) | def send_transaction(self, uri: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
06b973f598bad177deacc9d664b451ca1812b9690fe4cd1b221a411423812700 | def build_transaction(self, uri: str, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, uri: str, tx_params: Optional[TxParams]=None) -> dict:
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).buildTransaction(tx_params.as_dict()) | def build_transaction(self, uri: str, tx_params: Optional[TxParams]=None) -> dict:
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
c4cddb6845437dd4d1c80a9cc8bb823b680428f801ebaefbb3d2181654fae7a7 | def estimate_gas(self, uri: str, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, uri: str, tx_params: Optional[TxParams]=None) -> int:
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).estimateGas(tx_params.as_dict()) | def estimate_gas(self, uri: str, tx_params: Optional[TxParams]=None) -> int:
uri = self.validate_and_normalize_inputs(uri)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(uri).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
fccf070b3b155bae730a319eadf40f72d2c96e44c3a90e4ab89d3f3fe6e833ec | def validate_and_normalize_inputs(self, royalty_recipient: str, royalty_bps: int):
'Validate the inputs to the setDefaultRoyaltyInfo method.'
self.validator.assert_valid(method_name='setDefaultRoyaltyInfo', parameter_name='_royaltyRecipient', argument_value=royalty_recipient)
royalty_recipient = self.validate_and_checksum_address(royalty_recipient)
self.validator.assert_valid(method_name='setDefaultRoyaltyInfo', parameter_name='_royaltyBps', argument_value=royalty_bps)
royalty_bps = int(royalty_bps)
return (royalty_recipient, royalty_bps) | Validate the inputs to the setDefaultRoyaltyInfo method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, royalty_recipient: str, royalty_bps: int):
self.validator.assert_valid(method_name='setDefaultRoyaltyInfo', parameter_name='_royaltyRecipient', argument_value=royalty_recipient)
royalty_recipient = self.validate_and_checksum_address(royalty_recipient)
self.validator.assert_valid(method_name='setDefaultRoyaltyInfo', parameter_name='_royaltyBps', argument_value=royalty_bps)
royalty_bps = int(royalty_bps)
return (royalty_recipient, royalty_bps) | def validate_and_normalize_inputs(self, royalty_recipient: str, royalty_bps: int):
self.validator.assert_valid(method_name='setDefaultRoyaltyInfo', parameter_name='_royaltyRecipient', argument_value=royalty_recipient)
royalty_recipient = self.validate_and_checksum_address(royalty_recipient)
self.validator.assert_valid(method_name='setDefaultRoyaltyInfo', parameter_name='_royaltyBps', argument_value=royalty_bps)
royalty_bps = int(royalty_bps)
return (royalty_recipient, royalty_bps)<|docstring|>Validate the inputs to the setDefaultRoyaltyInfo method.<|endoftext|> |
c11d50e9a155ee8db1b38c15fda0e8a2e3af026de4e1db939569aa31fed0ab52 | def call(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(royalty_recipient, royalty_bps).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(royalty_recipient, royalty_bps).call(tx_params.as_dict()) | def call(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(royalty_recipient, royalty_bps).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
4f97731c6a6b9577d1c1564d161d4b9026cd7db3befd786ba9fa338cadd0a099 | def send_transaction(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).transact(tx_params.as_dict()) | def send_transaction(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
c051543864f64062a967846810d382542102d109101cfdbb373f4a6c95b60213 | def build_transaction(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> dict:
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).buildTransaction(tx_params.as_dict()) | def build_transaction(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> dict:
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
24334490e687ad1c354cb8665b1a74a2ff4995f94ee8f7cc2c46dbb082cf87d4 | def estimate_gas(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> int:
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).estimateGas(tx_params.as_dict()) | def estimate_gas(self, royalty_recipient: str, royalty_bps: int, tx_params: Optional[TxParams]=None) -> int:
(royalty_recipient, royalty_bps) = self.validate_and_normalize_inputs(royalty_recipient, royalty_bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(royalty_recipient, royalty_bps).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
742fb75de2baaa4eb66df5f6e12c452234d91435ac3ba961d7ae19f755dc86b6 | def validate_and_normalize_inputs(self, new_owner: str):
'Validate the inputs to the setOwner method.'
self.validator.assert_valid(method_name='setOwner', parameter_name='_newOwner', argument_value=new_owner)
new_owner = self.validate_and_checksum_address(new_owner)
return new_owner | Validate the inputs to the setOwner method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, new_owner: str):
self.validator.assert_valid(method_name='setOwner', parameter_name='_newOwner', argument_value=new_owner)
new_owner = self.validate_and_checksum_address(new_owner)
return new_owner | def validate_and_normalize_inputs(self, new_owner: str):
self.validator.assert_valid(method_name='setOwner', parameter_name='_newOwner', argument_value=new_owner)
new_owner = self.validate_and_checksum_address(new_owner)
return new_owner<|docstring|>Validate the inputs to the setOwner method.<|endoftext|> |
6681b25045b64e9e1f3d0012c2fd2c9ad37a82f383be850cbbd66f420a2e2d6b | def call(self, new_owner: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(new_owner).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, new_owner: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(new_owner).call(tx_params.as_dict()) | def call(self, new_owner: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(new_owner).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
a9111d22c74380d309c72f293580c76d59163088463909b228bf9c769f637868 | def send_transaction(self, new_owner: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, new_owner: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).transact(tx_params.as_dict()) | def send_transaction(self, new_owner: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
9c15a7de56214e952aa21b13020357198a03f4635caad8c156f6a13b8dd33729 | def build_transaction(self, new_owner: str, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, new_owner: str, tx_params: Optional[TxParams]=None) -> dict:
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).buildTransaction(tx_params.as_dict()) | def build_transaction(self, new_owner: str, tx_params: Optional[TxParams]=None) -> dict:
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
e77e1bc002d377475f45cd1818c2cf0c72c101fcb955d1d0b0e42c048e75c022 | def estimate_gas(self, new_owner: str, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, new_owner: str, tx_params: Optional[TxParams]=None) -> int:
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).estimateGas(tx_params.as_dict()) | def estimate_gas(self, new_owner: str, tx_params: Optional[TxParams]=None) -> int:
new_owner = self.validate_and_normalize_inputs(new_owner)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(new_owner).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
c1cb5b11298491b1a1d7bd2c9981cba3277ead63d9326802c912cc41e44db73d | def validate_and_normalize_inputs(self, token_id: int, recipient: str, bps: int):
'Validate the inputs to the setRoyaltyInfoForToken method.'
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_bps', argument_value=bps)
bps = int(bps)
return (token_id, recipient, bps) | Validate the inputs to the setRoyaltyInfoForToken method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, token_id: int, recipient: str, bps: int):
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_bps', argument_value=bps)
bps = int(bps)
return (token_id, recipient, bps) | def validate_and_normalize_inputs(self, token_id: int, recipient: str, bps: int):
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
self.validator.assert_valid(method_name='setRoyaltyInfoForToken', parameter_name='_bps', argument_value=bps)
bps = int(bps)
return (token_id, recipient, bps)<|docstring|>Validate the inputs to the setRoyaltyInfoForToken method.<|endoftext|> |
f88263017135c90310af766f39120d9154b5a58b0f5a6d7648cbb59d442d3296 | def call(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(token_id, recipient, bps).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(token_id, recipient, bps).call(tx_params.as_dict()) | def call(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(token_id, recipient, bps).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
9812d9f132acf289a40b2dc92ffeb2175bb6bdd5aa4584edba0d245341b53f13 | def send_transaction(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).transact(tx_params.as_dict()) | def send_transaction(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
d39338f2f611008a6144e6ac109bb7dc917da086cf0bd9064c9cb6c261dbb157 | def build_transaction(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> dict:
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).buildTransaction(tx_params.as_dict()) | def build_transaction(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> dict:
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
24d44942f2a4f428d831cdb1fbaee117f927c78905a7975f2dc09b0382695973 | def estimate_gas(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> int:
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).estimateGas(tx_params.as_dict()) | def estimate_gas(self, token_id: int, recipient: str, bps: int, tx_params: Optional[TxParams]=None) -> int:
(token_id, recipient, bps) = self.validate_and_normalize_inputs(token_id, recipient, bps)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient, bps).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
05a5255a028f420a2cb78bcebacdded2e80991e15389d6bce3435493d661398c | def validate_and_normalize_inputs(self, interface_id: Union[(bytes, str)]):
'Validate the inputs to the supportsInterface method.'
self.validator.assert_valid(method_name='supportsInterface', parameter_name='interfaceId', argument_value=interface_id)
return interface_id | Validate the inputs to the supportsInterface method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, interface_id: Union[(bytes, str)]):
self.validator.assert_valid(method_name='supportsInterface', parameter_name='interfaceId', argument_value=interface_id)
return interface_id | def validate_and_normalize_inputs(self, interface_id: Union[(bytes, str)]):
self.validator.assert_valid(method_name='supportsInterface', parameter_name='interfaceId', argument_value=interface_id)
return interface_id<|docstring|>Validate the inputs to the supportsInterface method.<|endoftext|> |
8ef1d3c57700ddaee78c80ad8f91113057af009e0e657f44e7a28758d85df066 | def call(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> bool:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(interface_id).call(tx_params.as_dict())
return bool(returned) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> bool:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(interface_id).call(tx_params.as_dict())
return bool(returned) | def call(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> bool:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(interface_id).call(tx_params.as_dict())
return bool(returned)<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
b2da93c44a80fddf8b218ce699a3b0390b8145ea0033f15546a546b8732c4e59 | def send_transaction(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).transact(tx_params.as_dict()) | def send_transaction(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
aef3d31c39d6fdf43408623d7db19d6429532aa22a8234043354427b5c495e1b | def build_transaction(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> dict:
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).buildTransaction(tx_params.as_dict()) | def build_transaction(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> dict:
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
3924b5a1a4d4be0e20d1f58c645f609631d3781a48610f3ebd4bb6e36f55e21a | def estimate_gas(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> int:
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).estimateGas(tx_params.as_dict()) | def estimate_gas(self, interface_id: Union[(bytes, str)], tx_params: Optional[TxParams]=None) -> int:
interface_id = self.validate_and_normalize_inputs(interface_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(interface_id).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
ca018593104d6b0dd61e4217621e13539160c2609a5e06c020c095c244014be4 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction):
super().__init__(web3_or_provider, contract_address)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction):
super().__init__(web3_or_provider, contract_address)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
ca32d6807ebd9ceb15a2b64a172e6e81cfc9485bd1945b8aaf7461f0c2f67e87 | def call(self, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method().call(tx_params.as_dict())
return str(returned) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method().call(tx_params.as_dict())
return str(returned) | def call(self, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method().call(tx_params.as_dict())
return str(returned)<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
9ea0157eb6440eac095230a57efab5746974fbf6138037de26bad21761597b37 | def send_transaction(self, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().transact(tx_params.as_dict()) | def send_transaction(self, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
6f2a541c7014fdc8f155b3763c2bdb103b684bbe9b83febdadafc5995b919d1d | def build_transaction(self, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, tx_params: Optional[TxParams]=None) -> dict:
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().buildTransaction(tx_params.as_dict()) | def build_transaction(self, tx_params: Optional[TxParams]=None) -> dict:
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
11d4f9b449306eaf388ea7867de46d23b67cc54826ff61b156b8775f61102218 | def estimate_gas(self, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, tx_params: Optional[TxParams]=None) -> int:
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict()) | def estimate_gas(self, tx_params: Optional[TxParams]=None) -> int:
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method().estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
0de9d2c46990c6237784ef7c935242c1b6abf7bdb3eab8bc80ca7e67fee965bf | def validate_and_normalize_inputs(self, token_id: int):
'Validate the inputs to the tokenURI method.'
self.validator.assert_valid(method_name='tokenURI', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
return token_id | Validate the inputs to the tokenURI method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, token_id: int):
self.validator.assert_valid(method_name='tokenURI', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
return token_id | def validate_and_normalize_inputs(self, token_id: int):
self.validator.assert_valid(method_name='tokenURI', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
return token_id<|docstring|>Validate the inputs to the tokenURI method.<|endoftext|> |
b4ffa91a77acf497f87845e803e7008e5aac6ef4505645f6d2a013bf16ca4e81 | def call(self, token_id: int, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id).call(tx_params.as_dict())
return str(returned) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, token_id: int, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id).call(tx_params.as_dict())
return str(returned) | def call(self, token_id: int, tx_params: Optional[TxParams]=None) -> str:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(token_id).call(tx_params.as_dict())
return str(returned)<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
e27f80815f34ab833e17016d58c78e88a1e64dce6c8824207fba04df6aa3d88e | def send_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).transact(tx_params.as_dict()) | def send_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
687dfac0950732365c580176289be1f67bed0b6a35eea8671dbe2d8d8c5059ec | def build_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).buildTransaction(tx_params.as_dict()) | def build_transaction(self, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
97cb33886d64af0a51559709537b845f521d6110be3b37d16b1d9830eccf83f5 | def estimate_gas(self, token_id: int, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, token_id: int, tx_params: Optional[TxParams]=None) -> int:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).estimateGas(tx_params.as_dict()) | def estimate_gas(self, token_id: int, tx_params: Optional[TxParams]=None) -> int:
token_id = self.validate_and_normalize_inputs(token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
728d15b239d40fd18c6e550b67601c260f70cac63dc4603d86c583026ff1a9a0 | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int):
'Validate the inputs to the transferFrom method.'
self.validator.assert_valid(method_name='transferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='transferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='transferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return (_from, to, token_id) | Validate the inputs to the transferFrom method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int):
self.validator.assert_valid(method_name='transferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='transferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='transferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return (_from, to, token_id) | def validate_and_normalize_inputs(self, _from: str, to: str, token_id: int):
self.validator.assert_valid(method_name='transferFrom', parameter_name='from', argument_value=_from)
_from = self.validate_and_checksum_address(_from)
self.validator.assert_valid(method_name='transferFrom', parameter_name='to', argument_value=to)
to = self.validate_and_checksum_address(to)
self.validator.assert_valid(method_name='transferFrom', parameter_name='tokenId', argument_value=token_id)
token_id = int(token_id)
return (_from, to, token_id)<|docstring|>Validate the inputs to the transferFrom method.<|endoftext|> |
55f5c0e01056ee361079040bd3db6271919a8c2068e4f3154b6fb1223d7014c1 | def call(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id).call(tx_params.as_dict()) | def call(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(_from, to, token_id).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
12f9716ee47d8eecc462eec7da1667449a8dcb834ceed990ff804a240a75f666 | def send_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).transact(tx_params.as_dict()) | def send_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
9533a1b6781c6eca4a1d4a4b5041ac3039ab3a92a9cda59defaf68a11d9b2790 | def build_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).buildTransaction(tx_params.as_dict()) | def build_transaction(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> dict:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
633806efea644a8125ef3cef45e3982fbea77d7f7afcde5641c8785c9cad2cb5 | def estimate_gas(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> int:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).estimateGas(tx_params.as_dict()) | def estimate_gas(self, _from: str, to: str, token_id: int, tx_params: Optional[TxParams]=None) -> int:
(_from, to, token_id) = self.validate_and_normalize_inputs(_from, to, token_id)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(_from, to, token_id).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
4a3efd7f77bc82a34b54978a6f77a0e81fe13c0589b84c89846512a6d29c0559 | def validate_and_normalize_inputs(self, token_id: int, recipient: str):
'Validate the inputs to the unwrap method.'
self.validator.assert_valid(method_name='unwrap', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='unwrap', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
return (token_id, recipient) | Validate the inputs to the unwrap method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, token_id: int, recipient: str):
self.validator.assert_valid(method_name='unwrap', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='unwrap', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
return (token_id, recipient) | def validate_and_normalize_inputs(self, token_id: int, recipient: str):
self.validator.assert_valid(method_name='unwrap', parameter_name='_tokenId', argument_value=token_id)
token_id = int(token_id)
self.validator.assert_valid(method_name='unwrap', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
return (token_id, recipient)<|docstring|>Validate the inputs to the unwrap method.<|endoftext|> |
42d1bfeb24aabd6d8a959fe95b0c4416ac3ad7fdce1994450af9d54ca6e89b50 | def call(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(token_id, recipient).call(tx_params.as_dict()) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(token_id, recipient).call(tx_params.as_dict()) | def call(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> None:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
self._underlying_method(token_id, recipient).call(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
a5c042910368d83198c3151f0b9824ee6eb13befe7806e9c3759fbe211d048a7 | def send_transaction(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).transact(tx_params.as_dict()) | def send_transaction(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
cec8e98977c695096067c626fd294fdde7dca1bc33d4e2c7da09652b1e014f56 | def build_transaction(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> dict:
'Construct calldata to be used as input to the method.'
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).buildTransaction(tx_params.as_dict()) | Construct calldata to be used as input to the method. | thirdweb/abi/multiwrap.py | build_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def build_transaction(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> dict:
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).buildTransaction(tx_params.as_dict()) | def build_transaction(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> dict:
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).buildTransaction(tx_params.as_dict())<|docstring|>Construct calldata to be used as input to the method.<|endoftext|> |
2a3103c431f2794fbdd597b20e96a269e55458f319460163821b670c25652fa4 | def estimate_gas(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> int:
'Estimate gas consumption of method call.'
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).estimateGas(tx_params.as_dict()) | Estimate gas consumption of method call. | thirdweb/abi/multiwrap.py | estimate_gas | nftlabs/nftlabs-sdk-python | 30 | python | def estimate_gas(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> int:
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).estimateGas(tx_params.as_dict()) | def estimate_gas(self, token_id: int, recipient: str, tx_params: Optional[TxParams]=None) -> int:
(token_id, recipient) = self.validate_and_normalize_inputs(token_id, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(token_id, recipient).estimateGas(tx_params.as_dict())<|docstring|>Estimate gas consumption of method call.<|endoftext|> |
bd6ecbd21737798857673ddd577f664fcc7a46e09b0c38a5ecabaa08667bed75 | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
'Persist instance data.'
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | Persist instance data. | thirdweb/abi/multiwrap.py | __init__ | nftlabs/nftlabs-sdk-python | 30 | python | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function | def __init__(self, web3_or_provider: Union[(Web3, BaseProvider)], contract_address: str, contract_function: ContractFunction, validator: Validator=None):
super().__init__(web3_or_provider, contract_address, validator)
self._underlying_method = contract_function<|docstring|>Persist instance data.<|endoftext|> |
4f62c7d97ad26aeb9c0f19beba67501ce6d2783baa3510167b27dc496526676b | def validate_and_normalize_inputs(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str):
'Validate the inputs to the wrap method.'
self.validator.assert_valid(method_name='wrap', parameter_name='_tokensToWrap', argument_value=tokens_to_wrap)
self.validator.assert_valid(method_name='wrap', parameter_name='_uriForWrappedToken', argument_value=uri_for_wrapped_token)
self.validator.assert_valid(method_name='wrap', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
return (tokens_to_wrap, uri_for_wrapped_token, recipient) | Validate the inputs to the wrap method. | thirdweb/abi/multiwrap.py | validate_and_normalize_inputs | nftlabs/nftlabs-sdk-python | 30 | python | def validate_and_normalize_inputs(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str):
self.validator.assert_valid(method_name='wrap', parameter_name='_tokensToWrap', argument_value=tokens_to_wrap)
self.validator.assert_valid(method_name='wrap', parameter_name='_uriForWrappedToken', argument_value=uri_for_wrapped_token)
self.validator.assert_valid(method_name='wrap', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
return (tokens_to_wrap, uri_for_wrapped_token, recipient) | def validate_and_normalize_inputs(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str):
self.validator.assert_valid(method_name='wrap', parameter_name='_tokensToWrap', argument_value=tokens_to_wrap)
self.validator.assert_valid(method_name='wrap', parameter_name='_uriForWrappedToken', argument_value=uri_for_wrapped_token)
self.validator.assert_valid(method_name='wrap', parameter_name='_recipient', argument_value=recipient)
recipient = self.validate_and_checksum_address(recipient)
return (tokens_to_wrap, uri_for_wrapped_token, recipient)<|docstring|>Validate the inputs to the wrap method.<|endoftext|> |
eebe0d8a73deff10c69799113e023c13a4937e2342a82503d242c509f6d67028 | def call(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str, tx_params: Optional[TxParams]=None) -> int:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(tokens_to_wrap, uri_for_wrapped_token, recipient) = self.validate_and_normalize_inputs(tokens_to_wrap, uri_for_wrapped_token, recipient)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(tokens_to_wrap, uri_for_wrapped_token, recipient).call(tx_params.as_dict())
return int(returned) | Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method. | thirdweb/abi/multiwrap.py | call | nftlabs/nftlabs-sdk-python | 30 | python | def call(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str, tx_params: Optional[TxParams]=None) -> int:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(tokens_to_wrap, uri_for_wrapped_token, recipient) = self.validate_and_normalize_inputs(tokens_to_wrap, uri_for_wrapped_token, recipient)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(tokens_to_wrap, uri_for_wrapped_token, recipient).call(tx_params.as_dict())
return int(returned) | def call(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str, tx_params: Optional[TxParams]=None) -> int:
'Execute underlying contract method via eth_call.\n\n :param tx_params: transaction parameters\n :returns: the return value of the underlying method.\n '
(tokens_to_wrap, uri_for_wrapped_token, recipient) = self.validate_and_normalize_inputs(tokens_to_wrap, uri_for_wrapped_token, recipient)
tx_params = super().normalize_tx_params(tx_params)
returned = self._underlying_method(tokens_to_wrap, uri_for_wrapped_token, recipient).call(tx_params.as_dict())
return int(returned)<|docstring|>Execute underlying contract method via eth_call.
:param tx_params: transaction parameters
:returns: the return value of the underlying method.<|endoftext|> |
c5ad15d73f2829f98e4b60f56be0f11707c7135cc6317a434bd9b6e531f03a98 | def send_transaction(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(tokens_to_wrap, uri_for_wrapped_token, recipient) = self.validate_and_normalize_inputs(tokens_to_wrap, uri_for_wrapped_token, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(tokens_to_wrap, uri_for_wrapped_token, recipient).transact(tx_params.as_dict()) | Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters | thirdweb/abi/multiwrap.py | send_transaction | nftlabs/nftlabs-sdk-python | 30 | python | def send_transaction(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(tokens_to_wrap, uri_for_wrapped_token, recipient) = self.validate_and_normalize_inputs(tokens_to_wrap, uri_for_wrapped_token, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(tokens_to_wrap, uri_for_wrapped_token, recipient).transact(tx_params.as_dict()) | def send_transaction(self, tokens_to_wrap: List[ITokenBundleToken], uri_for_wrapped_token: str, recipient: str, tx_params: Optional[TxParams]=None) -> Union[(HexBytes, bytes)]:
'Execute underlying contract method via eth_sendTransaction.\n\n :param tx_params: transaction parameters\n '
(tokens_to_wrap, uri_for_wrapped_token, recipient) = self.validate_and_normalize_inputs(tokens_to_wrap, uri_for_wrapped_token, recipient)
tx_params = super().normalize_tx_params(tx_params)
return self._underlying_method(tokens_to_wrap, uri_for_wrapped_token, recipient).transact(tx_params.as_dict())<|docstring|>Execute underlying contract method via eth_sendTransaction.
:param tx_params: transaction parameters<|endoftext|> |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.