opinion-clob-sdk 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/safe_tx.py

@@ -0,0 +1,437 @@
+from functools import cached_property
+from typing import Any, Dict, List, NoReturn, Optional, Tuple, Type
+
+from eth_account import Account
+from eth_typing import ChecksumAddress
+from hexbytes import HexBytes
+from packaging.version import Version
+from web3 import Web3
+from web3.contract.contract import ContractFunction
+from web3.exceptions import Web3Exception
+from web3.types import BlockIdentifier, Nonce, TxParams, Wei
+
+from .constants import NULL_ADDRESS, TxSpeed
+from .safe_contracts.utils import get_safe_contract
+from .eip712 import eip712_encode
+
+from .utils import fast_keccak
+from .exceptions import (
+    CouldNotFinishInitialization,
+    CouldNotPayGasWithEther,
+    CouldNotPayGasWithToken,
+    HashHasNotBeenApproved,
+    InvalidContractSignatureLocation,
+    InvalidInternalTx,
+    InvalidMultisigTx,
+    InvalidOwnerProvided,
+    InvalidSignaturesProvided,
+    MethodCanOnlyBeCalledFromThisContract,
+    ModuleManagerException,
+    NotEnoughSafeTransactionGas,
+    OnlyOwnersCanApproveAHash,
+    OwnerManagerException,
+    SafeTransactionFailedWhenGasPriceAndSafeTxGasEmpty,
+    SignatureNotProvidedByOwner,
+    SignaturesDataTooShort,
+    ThresholdNeedsToBeDefined,
+)
+from .safe_signature import SafeSignature
+from .signatures import signature_to_bytes
+
+
+class SafeTx:
+    def __init__(
+        self,
+        w3: Web3,
+        safe_address: ChecksumAddress,
+        to: Optional[ChecksumAddress],
+        value: int,
+        data: bytes,
+        operation: int,
+        safe_tx_gas: int,
+        base_gas: int,
+        gas_price: int,
+        gas_token: Optional[ChecksumAddress],
+        refund_receiver: Optional[ChecksumAddress],
+        signatures: Optional[bytes] = None,
+        safe_nonce: Optional[int] = None,
+        safe_version: Optional[str] = None,
+        chain_id: Optional[int] = None,
+    ):
+        """
+        :param w3:
+        :param safe_address:
+        :param to:
+        :param value:
+        :param data:
+        :param operation:
+        :param safe_tx_gas:
+        :param base_gas:
+        :param gas_price:
+        :param gas_token:
+        :param refund_receiver:
+        :param signatures:
+        :param safe_nonce: Current nonce of the Safe. If not provided, it will be retrieved from network
+        :param safe_version: Safe version 1.0.0 renamed `baseGas` to `dataGas`. Safe version 1.3.0 added `chainId` to
+        the `domainSeparator`. If not provided, it will be retrieved from network
+        :param chain_id: Ethereum network chain_id is used in hash calculation for Safes >= 1.3.0. If not provided,
+        it will be retrieved from the provided ethereum_client
+        """
+
+        self.w3 = w3
+        self.safe_address = safe_address
+        self.to = to or NULL_ADDRESS
+        self.value = int(value)
+        self.data = HexBytes(data) if data else b""
+        self.operation = int(operation)
+        self.safe_tx_gas = int(safe_tx_gas)
+        self.base_gas = int(base_gas)
+        self.gas_price = int(gas_price)
+        self.gas_token = gas_token or NULL_ADDRESS
+        self.refund_receiver = refund_receiver or NULL_ADDRESS
+        self.signatures = signatures or b""
+        self._safe_nonce = safe_nonce and int(safe_nonce)
+        self._safe_version = safe_version
+        self._chain_id = chain_id and int(chain_id)
+
+        self.tx: Optional[TxParams] = None  # If executed, `tx` is set
+        self.tx_hash: Optional[bytes] = None  # If executed, `tx_hash` is set
+
+    def __str__(self):
+        return (
+            f"SafeTx - safe={self.safe_address} - to={self.to} - value={self.value} - data={self.data.hex()} - "
+            f"operation={self.operation} - safe-tx-gas={self.safe_tx_gas} - base-gas={self.base_gas} - "
+            f"gas-price={self.gas_price} - gas-token={self.gas_token} - refund-receiver={self.refund_receiver} - "
+            f"signers = {self.signers}"
+        )
+
+    @cached_property
+    def contract(self):
+        return get_safe_contract(self.w3, address=self.safe_address)
+
+    @cached_property
+    def chain_id(self) -> int:
+        if self._chain_id is not None:
+            return self._chain_id
+        else:
+            return self.w3.eth.chain_id
+
+    @cached_property
+    def safe_nonce(self) -> int:
+        if self._safe_nonce is not None:
+            return self._safe_nonce
+        else:
+            return self.contract.functions.nonce().call()
+
+    @cached_property
+    def safe_version(self) -> str:
+        if self._safe_version is not None:
+            return self._safe_version
+        else:
+            return self.contract.functions.VERSION().call()
+
+    @property
+    def eip712_structured_data(self) -> Dict[str, Any]:
+        safe_version = Version(self.safe_version)
+
+        # Safes >= 1.0.0 Renamed `baseGas` to `dataGas`
+        base_gas_key = "baseGas" if safe_version >= Version("1.0.0") else "dataGas"
+
+        types = {
+            "EIP712Domain": [{"name": "verifyingContract", "type": "address"}],
+            "SafeTx": [
+                {"name": "to", "type": "address"},
+                {"name": "value", "type": "uint256"},
+                {"name": "data", "type": "bytes"},
+                {"name": "operation", "type": "uint8"},
+                {"name": "safeTxGas", "type": "uint256"},
+                {"name": base_gas_key, "type": "uint256"},
+                {"name": "gasPrice", "type": "uint256"},
+                {"name": "gasToken", "type": "address"},
+                {"name": "refundReceiver", "type": "address"},
+                {"name": "nonce", "type": "uint256"},
+            ],
+        }
+        message = {
+            "to": self.to,
+            "value": self.value,
+            "data": self.data,
+            "operation": self.operation,
+            "safeTxGas": self.safe_tx_gas,
+            base_gas_key: self.base_gas,
+            "dataGas": self.base_gas,
+            "gasPrice": self.gas_price,
+            "gasToken": self.gas_token,
+            "refundReceiver": self.refund_receiver,
+            "nonce": self.safe_nonce,
+        }
+
+        payload: Dict[str, Any] = {
+            "types": types,
+            "primaryType": "SafeTx",
+            "domain": {"verifyingContract": self.safe_address},
+            "message": message,
+        }
+
+        # Enable chainId from v1.3.0 onwards
+        if safe_version >= Version("1.3.0"):
+            payload["domain"]["chainId"] = self.chain_id
+            types["EIP712Domain"].insert(0, {"name": "chainId", "type": "uint256"})
+
+        return payload
+
+    @property
+    def safe_tx_hash_preimage(self) -> HexBytes:
+        return HexBytes(b"".join(eip712_encode(self.eip712_structured_data)))
+
+    @property
+    def safe_tx_hash(self) -> HexBytes:
+        return HexBytes(fast_keccak(self.safe_tx_hash_preimage))
+
+    @property
+    def signers(self) -> List[str]:
+        if not self.signatures:
+            return []
+        else:
+            return [
+                safe_signature.owner
+                for safe_signature in SafeSignature.parse_signature(
+                    self.signatures, self.safe_tx_hash
+                )
+            ]
+
+    @property
+    def sorted_signers(self):
+        return sorted(self.signers, key=lambda x: int(x, 16))
+
+    @property
+    def w3_tx(self) -> ContractFunction:
+        """
+        :return: Web3 contract tx prepared for `call`, `transact` or `build_transaction`
+        """
+        return self.contract.functions.execTransaction(
+            self.to,
+            self.value,
+            self.data,
+            self.operation,
+            self.safe_tx_gas,
+            self.base_gas,
+            self.gas_price,
+            self.gas_token,
+            self.refund_receiver,
+            self.signatures,
+        )
+
+    def _raise_safe_vm_exception(self, message: str) -> NoReturn:
+        error_with_exception: Dict[str, Type[InvalidMultisigTx]] = {
+            # https://github.com/safe-global/safe-contracts/blob/v1.3.0/docs/error_codes.md
+            "GS000": CouldNotFinishInitialization,
+            "GS001": ThresholdNeedsToBeDefined,
+            "Could not pay gas costs with ether": CouldNotPayGasWithEther,
+            "GS011": CouldNotPayGasWithEther,
+            "Could not pay gas costs with token": CouldNotPayGasWithToken,
+            "GS012": CouldNotPayGasWithToken,
+            "GS013": SafeTransactionFailedWhenGasPriceAndSafeTxGasEmpty,
+            "Hash has not been approved": HashHasNotBeenApproved,
+            "Hash not approved": HashHasNotBeenApproved,
+            "GS025": HashHasNotBeenApproved,
+            "Invalid contract signature location: data not complete": InvalidContractSignatureLocation,
+            "GS023": InvalidContractSignatureLocation,
+            "Invalid contract signature location: inside static part": InvalidContractSignatureLocation,
+            "GS021": InvalidContractSignatureLocation,
+            "Invalid contract signature location: length not present": InvalidContractSignatureLocation,
+            "GS022": InvalidContractSignatureLocation,
+            "Invalid contract signature provided": InvalidContractSignatureLocation,
+            "GS024": InvalidContractSignatureLocation,
+            "Invalid owner provided": InvalidOwnerProvided,
+            "Invalid owner address provided": InvalidOwnerProvided,
+            "GS026": InvalidOwnerProvided,
+            "Invalid signatures provided": InvalidSignaturesProvided,
+            "Not enough gas to execute safe transaction": NotEnoughSafeTransactionGas,
+            "GS010": NotEnoughSafeTransactionGas,
+            "Only owners can approve a hash": OnlyOwnersCanApproveAHash,
+            "GS030": OnlyOwnersCanApproveAHash,
+            "GS031": MethodCanOnlyBeCalledFromThisContract,
+            "Signature not provided by owner": SignatureNotProvidedByOwner,
+            "Signatures data too short": SignaturesDataTooShort,
+            "GS020": SignaturesDataTooShort,
+            # ModuleManager
+            "GS100": ModuleManagerException,
+            "Invalid module address provided": ModuleManagerException,
+            "GS101": ModuleManagerException,
+            "GS102": ModuleManagerException,
+            "Invalid prevModule, module pair provided": ModuleManagerException,
+            "GS103": ModuleManagerException,
+            "Method can only be called from an enabled module": ModuleManagerException,
+            "GS104": ModuleManagerException,
+            "Module has already been added": ModuleManagerException,
+            # OwnerManager
+            "Address is already an owner": OwnerManagerException,
+            "GS200": OwnerManagerException,  # Owners have already been setup
+            "GS201": OwnerManagerException,  # Threshold cannot exceed owner count
+            "GS202": OwnerManagerException,  # Invalid owner address provided
+            "GS203": OwnerManagerException,  # Invalid ower address provided
+            "GS204": OwnerManagerException,  # Address is already an owner
+            "GS205": OwnerManagerException,  # Invalid prevOwner, owner pair provided
+            "Invalid prevOwner, owner pair provided": OwnerManagerException,
+            "New owner count needs to be larger than new threshold": OwnerManagerException,
+            "Threshold cannot exceed owner count": OwnerManagerException,
+            "Threshold needs to be greater than 0": OwnerManagerException,
+        }
+
+        for reason, custom_exception in error_with_exception.items():
+            if reason in message:
+                raise custom_exception(message)
+        raise InvalidMultisigTx(message)
+
+    def call(
+        self,
+        tx_sender_address: Optional[str] = None,
+        tx_gas: Optional[int] = None,
+        block_identifier: Optional[BlockIdentifier] = "latest",
+    ) -> int:
+        """
+        :param tx_sender_address:
+        :param tx_gas: Force a gas limit
+        :param block_identifier:
+        :return: `1` if everything ok
+        """
+        parameters: TxParams = {
+            "from": tx_sender_address if tx_sender_address else self.safe_address
+        }
+
+        if tx_gas:
+            parameters["gas"] = tx_gas
+        try:
+            success = self.w3_tx.call(
+                parameters,
+                block_identifier=block_identifier
+                if block_identifier is not None
+                else "latest",
+            )
+
+            if not success:
+                raise InvalidInternalTx(
+                    "Success bit is %d, should be equal to 1" % success
+                )
+            return success
+        except (Web3Exception, ValueError) as exc:
+            # e.g. web3.exceptions.ContractLogicError: execution reverted: Invalid owner provided
+            return self._raise_safe_vm_exception(str(exc))
+        except ValueError as exc:  # Parity
+            """
+            Parity throws a ValueError, e.g.
+            {'code': -32015,
+             'message': 'VM execution error.',
+             'data': 'Reverted 0x08c379a0000000000000000000000000000000000000000000000000000000000000020000000000000000
+                      000000000000000000000000000000000000000000000001b496e76616c6964207369676e6174757265732070726f7669
+                      6465640000000000'
+            }
+            """
+            error_dict = exc.args[0]
+            data = error_dict.get("data")
+            if data and isinstance(data, str) and "Reverted " in data:
+                # Parity
+                result = HexBytes(data.replace("Reverted ", ""))
+                return self._raise_safe_vm_exception(str(result))
+            else:
+                raise exc
+
+    def recommended_gas(self) -> Wei:
+        """
+        :return: Recommended gas to use on the ethereum_tx
+        """
+        return Wei(self.base_gas + self.safe_tx_gas + 75000)
+
+    def execute(
+        self,
+        tx_sender_private_key: str,
+        tx_gas: Optional[int] = None,
+        tx_gas_price: Optional[int] = None,
+        tx_nonce: Optional[int] = None,
+        block_identifier: Optional[BlockIdentifier] = "latest",
+        eip1559_speed: Optional[TxSpeed] = None,
+    ) -> Tuple[HexBytes, TxParams]:
+        """
+        Send multisig tx to the Safe
+
+        :param tx_sender_private_key: Sender private key
+        :param tx_gas: Gas for the external tx. If not, `(safe_tx_gas + base_gas) * 2` will be used
+        :param tx_gas_price: Gas price of the external tx. If not, `gas_price` will be used
+        :param tx_nonce: Force nonce for `tx_sender`
+        :param block_identifier: `latest` or `pending`
+        :param eip1559_speed: If provided, use EIP1559 transaction
+        :return: Tuple(tx_hash, tx)
+        :raises: InvalidMultisigTx: If user tx cannot go through the Safe
+        """
+
+        sender_account = Account.from_key(tx_sender_private_key)
+        if eip1559_speed and self.ethereum_client.is_eip1559_supported():
+            tx_parameters = self.ethereum_client.set_eip1559_fees(
+                {
+                    "from": sender_account.address,
+                },
+                tx_speed=eip1559_speed,
+            )
+        else:
+            tx_parameters = {
+                "from": sender_account.address,
+                "gasPrice": Wei(tx_gas_price)
+                if tx_gas_price
+                else self.w3.eth.gas_price,
+            }
+
+        if tx_gas:
+            tx_parameters["gas"] = tx_gas
+        if tx_nonce is not None:
+            tx_parameters["nonce"] = Nonce(tx_nonce)
+
+        self.tx = self.w3_tx.build_transaction(tx_parameters)
+        self.tx["gas"] = Wei(
+            tx_gas or (max(self.tx["gas"] + 75000, self.recommended_gas()))
+        )
+
+        self.tx_hash = self.ethereum_client.send_unsigned_transaction(
+            self.tx,
+            private_key=sender_account.key,
+            retry=False if tx_nonce is not None else True,
+            block_identifier=block_identifier,
+        )
+
+        # Set signatures empty after executing the tx. `Nonce` is increased even if it fails,
+        # so signatures are not valid anymore
+        self.signatures = b""
+        return self.tx_hash, self.tx
+
+    def sign(self, private_key: str) -> bytes:
+        """
+        {bytes32 r}{bytes32 s}{uint8 v}
+        :param private_key:
+        :return: Signature
+        """
+        account = Account.from_key(private_key)
+        signature_dict = account.unsafe_sign_hash(self.safe_tx_hash)
+        signature = signature_to_bytes(
+            signature_dict["v"], signature_dict["r"], signature_dict["s"]
+        )
+
+        # Insert signature sorted
+        if account.address not in self.signers:
+            unsorted_signatures = SafeSignature.parse_signature(
+                self.signatures + signature, self.safe_tx_hash
+            )
+            self.signatures = SafeSignature.export_signatures(unsorted_signatures)
+
+        return signature
+
+    def unsign(self, address: str) -> bool:
+        current_tx_signatures = SafeSignature.parse_signature(
+            self.signatures, self.safe_tx_hash
+        )
+        filtered_tx_signatures = list(
+            filter(lambda x: x.owner != address, current_tx_signatures)
+        )
+        if current_tx_signatures != filtered_tx_signatures:
+            self.signatures = SafeSignature.export_signatures(filtered_tx_signatures)
+            return True
+        return False

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/signatures.py

@@ -0,0 +1,63 @@
+from typing import List, Tuple, Union
+
+from eth_keys import keys
+from eth_keys.exceptions import BadSignature
+from hexbytes import HexBytes
+
+from .constants import NULL_ADDRESS
+
+
+def signature_split(
+    signatures: Union[bytes, str], pos: int = 0
+) -> Tuple[int, int, int]:
+    """
+    :param signatures: signatures in form of {bytes32 r}{bytes32 s}{uint8 v}
+    :param pos: position of the signature
+    :return: Tuple with v, r, s
+    """
+    signatures = HexBytes(signatures)
+    signature_pos = 65 * pos
+    if len(signatures[signature_pos : signature_pos + 65]) < 65:
+        raise ValueError(f"Signature must be at least 65 bytes {signatures.hex()}")
+    r = int.from_bytes(signatures[signature_pos : 32 + signature_pos], "big")
+    s = int.from_bytes(signatures[32 + signature_pos : 64 + signature_pos], "big")
+    v = signatures[64 + signature_pos]
+
+    return v, r, s
+
+
+def signature_to_bytes(v: int, r: int, s: int) -> bytes:
+    """
+    Convert ecdsa signature to bytes
+    :param v:
+    :param r:
+    :param s:
+    :return: signature in form of {bytes32 r}{bytes32 s}{uint8 v}
+    """
+
+    return (
+        r.to_bytes(32, byteorder="big")
+        + s.to_bytes(32, byteorder="big")
+        + v.to_bytes(1, byteorder="big")
+    )
+
+
+def signatures_to_bytes(signatures: List[Tuple[int, int, int]]) -> bytes:
+    """
+    Convert signatures to bytes
+    :param signatures: list of tuples(v, r, s)
+    :return: 65 bytes per signature
+    """
+    return b"".join([signature_to_bytes(v, r, s) for v, r, s in signatures])
+
+
+def get_signing_address(signed_hash: bytes, v: int, r: int, s: int) -> str:
+    """
+    :return: checksummed ethereum address, for example `0x568c93675A8dEb121700A6FAdDdfE7DFAb66Ae4A`
+    :rtype: str or `NULL_ADDRESS` if signature is not valid
+    """
+    try:
+        public_key = keys.ecdsa_recover(signed_hash, keys.Signature(vrs=(v - 27, r, s)))
+        return public_key.to_checksum_address()
+    except BadSignature:
+        return NULL_ADDRESS

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/typing.py

@@ -0,0 +1,17 @@
+from typing import Any, Dict, Optional, TypedDict, Union
+
+from eth_typing import ChecksumAddress, Hash32, HexStr
+from hexbytes import HexBytes
+from web3.types import LogReceipt
+
+EthereumHash = Union[Hash32, HexBytes, HexStr]
+EthereumData = Union[bytes, HexStr]
+
+
+class BalanceDict(TypedDict):
+    token_address: Optional[ChecksumAddress]
+    balance: int
+
+
+class LogReceiptDecoded(LogReceipt):
+    args: Dict[str, Any]