opinion-clob-sdk 0.1.9__py3-none-any.whl → 0.4.2__py3-none-any.whl

opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/opinion_clob_sdk/chain/safe/multisend.py

@@ -1,347 +0,0 @@
-from enum import Enum
-from logging import getLogger
-import logging
-from typing import List, Optional, Union, Literal
-
-from eth_typing import ChecksumAddress, HexAddress, HexStr, BlockNumber, Hash32
-from hexbytes import HexBytes
-from web3 import Web3
-from web3.types import TxParams, StateOverrideParams
-from .enums import SafeOperationEnum
-
-from .safe_contracts.utils import (
-    get_multi_send_contract,
-)
-from .typing import EthereumData
-from .utils import (
-    fast_bytes_to_checksum_address,
-    fast_is_checksum_address,
-    get_empty_tx_params,
-)
-
-logger = getLogger(__name__)
-
-
-class MultiSendOperation(Enum):
-    CALL = 0
-    DELEGATE_CALL = 1
-
-
-class MultiSendTx:
-    """
-    Wrapper for a single MultiSendTx
-    """
-
-    def __init__(
-        self,
-        operation: MultiSendOperation,
-        to: ChecksumAddress,
-        value: int,
-        data: EthereumData,
-        old_encoding: bool = False,
-    ):
-        """
-        :param operation: MultisendOperation, CALL or DELEGATE_CALL
-        :param to: Address
-        :param value: Value in Wei
-        :param data: data as hex string or bytes
-        :param old_encoding: True if using old multisend ABI Encoded data, False otherwise
-        """
-        self.operation = operation
-        self.to = to
-        self.value = value
-        self.data = HexBytes(data) if data else b""
-        self.old_encoding = old_encoding
-
-    def __eq__(self, other):
-        if not isinstance(other, MultiSendTx):
-            return NotImplemented
-
-        return (
-            self.operation == other.operation
-            and self.to == other.to
-            and self.value == other.value
-            and self.data == other.data
-        )
-
-    def __len__(self):
-        """
-        :return: Size on bytes of the tx
-        """
-        return 21 + 32 * 2 + self.data_length
-
-    def __repr__(self):
-        data = self.data[:4].hex() + ("..." if len(self.data) > 4 else "")
-        return (
-            f"MultisendTx operation={self.operation.name} to={self.to} value={self.value} "
-            f"data={data}"
-        )
-
-    @property
-    def data_length(self) -> int:
-        return len(self.data)
-
-    @property
-    def encoded_data(self):
-        operation = HexBytes("{:0>2x}".format(self.operation))  # Operation 1 byte
-        to = HexBytes("{:0>40x}".format(int(self.to, 16)))  # Address 20 bytes
-        value = HexBytes("{:0>64x}".format(self.value))  # Value 32 bytes
-        data_length = HexBytes(
-            "{:0>64x}".format(self.data_length)
-        )  # Data length 32 bytes
-        return operation + to + value + data_length + self.data
-
-    @classmethod
-    def from_bytes(cls, encoded_multisend_tx: Union[str, bytes]) -> "MultiSendTx":
-        """
-        Decoded one MultiSend transaction. ABI must be used to get the `transactions` parameter and use that data
-        for this function
-        :param encoded_multisend_tx:
-        :return:
-        """
-        encoded_multisend_tx = HexBytes(encoded_multisend_tx)
-        try:
-            return cls._decode_multisend_data(encoded_multisend_tx)
-        except ValueError:
-            # Try using the old decoding method
-            return cls._decode_multisend_old_transaction(encoded_multisend_tx)
-
-    @classmethod
-    def _decode_multisend_data(cls, encoded_multisend_tx: Union[str, bytes]):
-        """
-        Decodes one Multisend transaction. If there's more data after `data` it's ignored. Fallbacks to the old
-        multisend structure if this structure cannot be decoded.
-        https://etherscan.io/address/0x8D29bE29923b68abfDD21e541b9374737B49cdAD#code
-        Structure:
-            - operation   -> MultiSendOperation 1 byte
-            - to          -> ethereum address 20 bytes
-            - value       -> tx value 32 bytes
-            - data_length -> 32 bytes
-            - data        -> `data_length` bytes
-        :param encoded_multisend_tx: 1 multisend transaction encoded
-        :return: Tx as a MultisendTx
-        """
-        encoded_multisend_tx = HexBytes(encoded_multisend_tx)
-        operation = MultiSendOperation(encoded_multisend_tx[0])
-        to = fast_bytes_to_checksum_address(encoded_multisend_tx[1 : 1 + 20])
-        value = int.from_bytes(encoded_multisend_tx[21 : 21 + 32], byteorder="big")
-        data_length = int.from_bytes(
-            encoded_multisend_tx[21 + 32 : 21 + 32 * 2], byteorder="big"
-        )
-        data = encoded_multisend_tx[21 + 32 * 2 : 21 + 32 * 2 + data_length]
-        len_data = len(data)
-        if len_data != data_length:
-            raise ValueError(
-                f"Data length {data_length} is different from len(data) {len_data}"
-            )
-        return cls(operation, to, value, data, old_encoding=False)
-
-    @classmethod
-    def _decode_multisend_old_transaction(
-        cls, encoded_multisend_tx: Union[str, bytes]
-    ) -> "MultiSendTx":
-        """
-        Decodes one old multisend transaction. If there's more data after `data` it's ignored. The difference with
-        the new MultiSend is that every value but `data` is padded to 32 bytes, wasting a lot of bytes.
-        https://etherscan.io/address/0xE74d6AF1670FB6560dd61EE29eB57C7Bc027Ce4E#code
-        Structure:
-            - operation   -> MultiSendOperation 32 byte
-            - to          -> ethereum address 32 bytes
-            - value       -> tx value 32 bytes
-            - data_length -> 32 bytes
-            - data        -> `data_length` bytes
-        :param encoded_multisend_tx: 1 multisend transaction encoded
-        :return: Tx as a MultisendTx
-        """
-        encoded_multisend_tx = HexBytes(encoded_multisend_tx)
-        operation = MultiSendOperation(
-            int.from_bytes(encoded_multisend_tx[:32], byteorder="big")
-        )
-        to = fast_bytes_to_checksum_address(encoded_multisend_tx[32:64][-20:])
-        value = int.from_bytes(encoded_multisend_tx[64:96], byteorder="big")
-        data_length = int.from_bytes(encoded_multisend_tx[128:160], byteorder="big")
-        data = encoded_multisend_tx[160 : 160 + data_length]
-        len_data = len(data)
-        if len_data != data_length:
-            raise ValueError(
-                f"Data length {data_length} is different from len(data) {len_data}"
-            )
-        return cls(operation, to, value, data, old_encoding=True)
-
-
-class MultiSend:
-    dummy_w3 = Web3()
-    MULTISEND_ADDRESSES = (
-        "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",  # MultiSend v1.3.0
-        "0x998739BFdAAdde7C933B942a68053933098f9EDa",  # MultiSend v1.3.0 (EIP-155)
-    )
-    MULTISEND_CALL_ONLY_ADDRESSES = (
-        "0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",  # MultiSend Call Only v1.3.0
-        "0xA1dabEF33b3B82c7814B6D82A79e50F4AC44102B",  # MultiSend Call Only v1.3.0 (EIP-155)
-    )
-
-    def __init__(
-        self,
-        w3: Optional[Web3] = None,
-        address: Optional[ChecksumAddress] = None,
-        call_only: bool = True,
-    ):
-        """
-        :param w3: Required for detecting the address in the network.
-        :param address: If not provided, will try to detect it from the hardcoded addresses using `ethereum_client`.
-        :param call_only: If `True` use `call only` MultiSend, otherwise use regular one.
-            Only if `address` not provided
-        """
-
-        self.address = address
-        self.w3 = w3 if w3 is not None else self.dummy_w3
-        self.call_only = call_only
-        multi_send_addresses = (
-            self.MULTISEND_CALL_ONLY_ADDRESSES
-            if call_only
-            else self.MULTISEND_ADDRESSES
-        )
-
-        if address:
-            assert fast_is_checksum_address(address), (
-                "%s proxy factory address not valid" % address
-            )
-        elif w3:
-            # Try to detect MultiSend address if not provided
-            for multi_send_address in multi_send_addresses:
-                multi_send_address_checksum = ChecksumAddress(
-                    HexAddress(HexStr(multi_send_address))
-                )
-
-                # Check if the address is contract
-                if len(w3.eth.get_code(multi_send_address_checksum)) != 0:
-                    self.address = multi_send_address_checksum
-                    break
-        else:
-            self.address = ChecksumAddress(HexAddress(HexStr(multi_send_addresses[0])))
-
-        if not self.address:
-            chain_id = (
-                self.w3.eth.chain_id if self.w3 != self.dummy_w3 else "N/A"
-            )
-            raise ValueError(f"Cannot find a MultiSend contract for chainId={chain_id}")
-
-    @classmethod
-    def from_bytes(cls, encoded_multisend_txs: Union[str, bytes]) -> List[MultiSendTx]:
-        """
-        Decodes one or more multisend transactions from `bytes transactions` (Abi decoded)
-
-        :param encoded_multisend_txs:
-        :return: List of MultiSendTxs
-        """
-        if not encoded_multisend_txs:
-            return []
-
-        encoded_multisend_txs = HexBytes(encoded_multisend_txs)
-        multisend_tx = MultiSendTx.from_bytes(encoded_multisend_txs)
-        multisend_tx_size = len(multisend_tx)
-
-        assert (
-            multisend_tx_size > 0
-        ), "Multisend tx cannot be empty"  # This should never happen, just in case
-        if multisend_tx.old_encoding:
-            next_data_position = (
-                (multisend_tx.data_length + 0x1F) // 0x20 * 0x20
-            ) + 0xA0
-        else:
-            next_data_position = multisend_tx_size
-        remaining_data = encoded_multisend_txs[next_data_position:]
-
-        return [multisend_tx] + cls.from_bytes(remaining_data)
-
-    @classmethod
-    def from_transaction_data(
-        cls, multisend_data: Union[str, bytes]
-    ) -> List[MultiSendTx]:
-        """
-        Decodes multisend transactions from transaction data (ABI encoded with selector)
-
-        :return:
-        """
-        try:
-            _, data = get_multi_send_contract(cls.dummy_w3).decode_function_input(
-                multisend_data
-            )
-            return cls.from_bytes(data["transactions"])
-        except ValueError:
-            return []
-
-    def get_contract(self):
-        return get_multi_send_contract(self.w3, self.address)
-
-    def build_tx(
-        self, multi_send_txs: List[MultiSendTx], tx_params: Optional[TxParams] = None
-    ) -> TxParams:
-        """
-        Txs don't need to be valid to get through
-
-        :param multi_send_txs:
-        :param tx_params:
-        :return:
-        """
-        multisend_contract = self.get_contract()
-        encoded_multisend_data = b"".join([x.encoded_data for x in multi_send_txs])
-        return multisend_contract.functions.multiSend(
-            encoded_multisend_data
-        ).build_transaction(tx_params or {})
-
-    def build_tx_data(self, multi_send_txs: List[MultiSendTx]) -> HexBytes:
-        """
-        Txs don't need to be valid to get through
-
-        :param multi_send_txs:
-        :return:
-        """
-        return HexBytes(
-            self.build_tx(multi_send_txs, tx_params=get_empty_tx_params())["data"]
-        )
-
-    def estimate_gas(
-        self,
-        multi_send_txs: List[MultiSendTx],
-        safe_address: ChecksumAddress,
-        safe_operation=SafeOperationEnum.DELEGATE_CALL.value,
-        block_identifier: Union[Literal["latest", "earliest", "pending", "safe", "finalized"], BlockNumber, Hash32, HexStr, HexBytes, int, None] = None,
-        state_override: Optional[dict[ChecksumAddress, StateOverrideParams]] = None
-    ) -> int:
-        """
-        Only support safe_operation == DELEGATE_CALL and multisend_operation == CALL for now.
-        :param multi_send_txs:
-        :param safe_address:
-        :param safe_operation:
-        :param block_identifier:
-        :param state_override:
-        :return:
-        """
-        if self.w3 == self.dummy_w3:
-            raise Exception("invalid web3 instance")
-        if safe_operation is not SafeOperationEnum.DELEGATE_CALL.value:
-            raise NotImplemented
-
-        from_address = safe_address
-
-        safe_gas = 0
-        for tx in multi_send_txs:
-            if tx.operation == MultiSendOperation.DELEGATE_CALL:
-                raise NotImplemented
-
-            tx_params = {
-                "from": from_address,
-                "to": tx.to,
-                "value": tx.value,
-                "data": '0x'+tx.data.hex(),
-            }
-
-            logging.debug(f'multisend.estimate_gas, tx_params: {tx_params}')
-            gas = self.w3.eth.estimate_gas(tx_params, block_identifier=block_identifier, state_override=state_override)
-            safe_gas += gas
-
-        # To protect safe transaction execution from network gas volatility
-        safe_gas *= 1.5
-
-        return safe_gas

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

@@ -1,141 +0,0 @@
-from eth_account import Account
-from web3 import Web3
-from eth_typing import ChecksumAddress, HexStr
-from typing import Any, Callable, Dict, List, Optional, Type, Union
-import logging
-
-from web3.middleware import SignAndSendRawMiddlewareBuilder
-
-from .enums import SafeOperationEnum
-from .constants import NULL_ADDRESS
-from .safe_tx import SafeTx
-from functools import cached_property
-from web3.types import BlockIdentifier, TxParams, Wei
-
-from .multisend import MultiSendTx, MultiSend
-from .safe_contracts.utils import get_safe_contract
-
-VERSION = 'v1.3.0'
-
-
-class Safe:
-    def __init__(
-            self,
-            w3: Web3,
-            private_key: HexStr,
-            address: ChecksumAddress,
-            multisend_address: ChecksumAddress
-    ):
-        account = Account.from_key(private_key)
-        w3.middleware_onion.inject(SignAndSendRawMiddlewareBuilder.build(account), layer=0)
-        self.w3 = w3
-
-        self.private_key = private_key
-        self.address = address
-        self.multisend_address = multisend_address
-        self.multisend = MultiSend(self.w3, self.multisend_address, False)
-        self.contract = get_safe_contract(self.w3, self.address)
-
-    @cached_property
-    def chain_id(self) -> int:
-        return self.w3.eth.chain_id
-
-    def get_version(self) -> str:
-        """
-        :return: String with Safe Master Copy semantic version, must match `retrieve_version()`
-        """
-        return VERSION
-
-    def retrieve_nonce(
-            self, block_identifier: Optional[BlockIdentifier] = "latest"
-    ) -> int:
-        return self.contract.functions.nonce().call(
-            block_identifier=block_identifier or "latest"
-        )
-
-    def build_multisend_tx(self,
-        multi_send_txs: List[MultiSendTx],
-        safe_nonce: Optional[int] = None,
-    ) ->  SafeTx:
-        safe_gas = self.multisend.estimate_gas(multi_send_txs, self.address)
-        data = self.multisend.build_tx_data(multi_send_txs)
-        safe_tx = self.build_multisig_tx(
-            to=self.multisend_address,
-            value=0,
-            data=data,
-            operation=SafeOperationEnum.DELEGATE_CALL.value,
-            safe_tx_gas=safe_gas,
-            safe_nonce=safe_nonce,
-        )
-
-        return safe_tx
-
-    def execute_multisend(self, multi_send_txs: List[MultiSendTx], safe_nonce: Optional[int] = None):
-        safe_tx = self.build_multisend_tx(multi_send_txs, safe_nonce)
-        safe_tx.sign(self.private_key)
-        safe_tx_gas = safe_tx.recommended_gas()
-        tx_params = {
-            "from": Account.from_key(self.private_key).address,
-            "gas": round(safe_tx_gas*1.2),
-        }
-        logging.debug(f'execute_multisend call with params: {tx_params}')
-
-        return_value = safe_tx.w3_tx.call(tx_params)
-        # return_value = None
-        logging.debug(f'execute_multisend return value: {return_value} for safe_nonce {safe_tx.safe_nonce}, w3_tx: {safe_tx.w3_tx}')
-        tx_hash = safe_tx.w3_tx.transact(tx_params)
-
-        return tx_hash, safe_tx.safe_tx_hash, return_value
-
-    def build_multisig_tx(
-            self,
-            to: ChecksumAddress,
-            value: int,
-            data: bytes,
-            operation: int = SafeOperationEnum.CALL.value,
-            safe_tx_gas: int = 0,
-            base_gas: int = 0,
-            gas_price: int = 0,
-            gas_token: ChecksumAddress = NULL_ADDRESS,
-            refund_receiver: ChecksumAddress = NULL_ADDRESS,
-            signatures: bytes = b"",
-            safe_nonce: Optional[int] = None,
-    ) -> SafeTx:
-        """
-        Allows to execute a Safe transaction confirmed by required number of owners and then pays the account
-        that submitted the transaction. The fees are always transfered, even if the user transaction fails
-
-        :param to: Destination address of Safe transaction
-        :param value: Ether value of Safe transaction
-        :param data: Data payload of Safe transaction
-        :param operation: Operation type of Safe transaction
-        :param safe_tx_gas: Gas that should be used for the Safe transaction
-        :param base_gas: Gas costs for that are independent of the transaction execution
-            (e.g. base transaction fee, signature check, payment of the refund)
-        :param gas_price: Gas price that should be used for the payment calculation
-        :param gas_token: Token address (or `0x000..000` if ETH) that is used for the payment
-        :param refund_receiver: Address of receiver of gas payment (or `0x000..000` if tx.origin).
-        :param signatures: Packed signature data ({bytes32 r}{bytes32 s}{uint8 v})
-        :param safe_nonce: Nonce of the safe (to calculate hash)
-        :return: SafeTx
-        """
-
-        if safe_nonce is None:
-            safe_nonce = self.retrieve_nonce()
-        return SafeTx(
-            self.w3,
-            self.address,
-            to,
-            value,
-            data,
-            operation,
-            safe_tx_gas,
-            base_gas,
-            gas_price,
-            gas_token,
-            refund_receiver,
-            signatures=signatures,
-            safe_nonce=safe_nonce,
-            safe_version=self.get_version(),
-            chain_id=self.chain_id,
-        )