tonutils 0.5.2__py3-none-any.whl → 0.6.0a1__py3-none-any.whl

tonutils/contracts/nft/collection.py

@@ -0,0 +1,116 @@
+import typing as t
+
+from pytoniq_core import (
+    Address,
+    Cell,
+    Slice,
+    StateInit,
+    begin_cell,
+)
+
+from .get_methods import NFTCollectionGetMethods
+from ..base import BaseContract
+from ...types import (
+    AddressLike,
+    NFTCollectionContent,
+    NFTCollectionData,
+    NFTCollectionVersion,
+    NFTItemVersion,
+    MetadataPrefix,
+    OnchainContent,
+    OffchainContent,
+    RoyaltyParams,
+    WorkchainID,
+)
+from ...utils import to_cell
+
+
+class BaseNFTCollection(BaseContract[NFTCollectionData]):
+    _data_model = NFTCollectionData
+    NFT_ITEM_VERSION: NFTItemVersion
+
+    @property
+    def owner_address(self) -> Address:
+        return self.state_data.owner_address
+
+    @property
+    def next_item_index(self) -> int:
+        return self.state_data.next_item_index
+
+    @property
+    def content(self) -> NFTCollectionContent:
+        return self.state_data.content
+
+    @property
+    def nft_item_code(self) -> Cell:
+        return self.state_data.nft_item_code
+
+    @classmethod
+    def calculate_nft_item_address(
+        cls,
+        index: int,
+        nft_item_code: t.Union[Cell, str],
+        collection_address: AddressLike,
+        workchain: WorkchainID = WorkchainID.BASECHAIN,
+    ) -> Address:
+        code = to_cell(nft_item_code)
+        data = begin_cell()
+        data.store_uint(index, 64)
+        data.store_address(collection_address)
+        state_init = StateInit(code=code, data=data.end_cell())
+        return Address((workchain.value, state_init.serialize().hash))
+
+    async def get_collection_data(self) -> t.Tuple[
+        int,
+        t.Union[OnchainContent, OffchainContent],
+        t.Optional[Address],
+    ]:
+        method_result = await NFTCollectionGetMethods.get_collection_data(
+            client=self.client,
+            address=self.address,
+        )
+        content_cs: Slice = method_result[1].begin_parse()
+        return (
+            method_result[0],
+            (
+                OnchainContent.deserialize(content_cs, False)
+                if content_cs.load_uint(8) == MetadataPrefix.ONCHAIN
+                else OffchainContent.deserialize(content_cs, False)
+            ),
+            method_result[2],
+        )
+
+    async def get_nft_content(
+        self,
+        index: int,
+        individual_nft_content: Cell,
+    ) -> OffchainContent:
+        cell = await NFTCollectionGetMethods.get_nft_content(
+            client=self.client,
+            address=self.address,
+            index=index,
+            individual_nft_content=individual_nft_content,
+        )
+        return OffchainContent.deserialize(cell.begin_parse(), True)
+
+    async def get_nft_address_by_index(self, index: int) -> Address:
+        return await NFTCollectionGetMethods.get_nft_address_by_index(
+            client=self.client,
+            address=self.address,
+            index=index,
+        )
+
+    async def royalty_params(self) -> RoyaltyParams:
+        royalty, denominator, address = await NFTCollectionGetMethods.royalty_params(
+            client=self.client,
+            address=self.address,
+        )
+        return RoyaltyParams(royalty, denominator, address)
+
+
+class NFTCollectionStandard(BaseNFTCollection):
+    VERSION = NFTCollectionVersion.NFTCollectionStandard
+
+
+class NFTCollectionEditable(BaseNFTCollection):
+    VERSION = NFTCollectionVersion.NFTCollectionEditable

tonutils/contracts/nft/get_methods.py

@@ -0,0 +1,124 @@
+import typing as t
+
+from pytoniq_core import Address, Cell
+
+from ...protocols import ClientProtocol
+
+
+class NFTCollectionGetMethods:
+
+    @classmethod
+    async def get_collection_data(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+    ) -> t.List[t.Any]:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_collection_data",
+        )
+        return method_result
+
+    @classmethod
+    async def get_nft_address_by_index(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+        index: int,
+    ) -> Address:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_nft_address_by_index",
+            stack=[index],
+        )
+        return method_result[0]
+
+    @classmethod
+    async def royalty_params(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+    ) -> t.List[t.Any]:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="royalty_params",
+        )
+        return method_result
+
+    @classmethod
+    async def get_nft_content(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+        index: int,
+        individual_nft_content: Cell,
+    ) -> Cell:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_nft_content",
+            stack=[index, individual_nft_content],
+        )
+        return method_result[0]
+
+    @classmethod
+    async def get_second_owner_address(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+    ) -> Address:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_second_owner_address",
+        )
+        return method_result[0]
+
+
+class NFTItemGetMethods:
+
+    @classmethod
+    async def get_nft_data(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+    ) -> t.List[t.Any]:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_nft_data",
+        )
+        return method_result
+
+    @classmethod
+    async def get_editor(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+    ) -> t.Optional[Address]:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_editor",
+        )
+        return method_result[0]
+
+    @classmethod
+    async def get_authority_address(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+    ) -> t.Optional[Address]:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_authority_address",
+        )
+        return method_result[0]
+
+    @classmethod
+    async def get_revoked_time(
+        cls,
+        client: ClientProtocol,
+        address: Address,
+    ) -> int:
+        method_result = await client.run_get_method(
+            address=address,
+            method_name="get_revoked_time",
+        )
+        return method_result[0]

tonutils/contracts/nft/item.py

@@ -0,0 +1,119 @@
+import abc
+import typing as t
+
+from pytoniq_core import Address, Slice
+
+from .get_methods import NFTItemGetMethods
+from ..base import BaseContract
+from ...types import (
+    NFTItemEditableData,
+    NFTItemSoulboundData,
+    NFTItemStandardData,
+    NFTItemVersion,
+    OffchainItemContent,
+)
+
+D = t.TypeVar(
+    "D",
+    bound=t.Union[
+        NFTItemEditableData,
+        NFTItemSoulboundData,
+        NFTItemStandardData,
+    ],
+)
+C = t.TypeVar("C", bound=OffchainItemContent)
+
+DStandard = t.TypeVar("DStandard", bound=NFTItemStandardData)
+DEditable = t.TypeVar("DEditable", bound=NFTItemEditableData)
+DSoulbound = t.TypeVar("DSoulbound", bound=NFTItemSoulboundData)
+
+
+class BaseNFTItem(BaseContract[D], t.Generic[D, C], abc.ABC):
+    _data_model: t.Type[D]
+
+    @property
+    def state_data(self) -> D:
+        return super().state_data
+
+    @property
+    def index(self) -> int:
+        return self.state_data.index
+
+    @property
+    def owner_address(self) -> Address:
+        return self.state_data.owner_address
+
+    @property
+    def collection_address(self) -> Address:
+        return self.state_data.collection_address
+
+    @property
+    def content(self) -> C:
+        return self.state_data.content
+
+    async def get_nft_data(
+        self,
+    ) -> t.Tuple[
+        bool,
+        int,
+        t.Optional[Address],
+        t.Optional[Address],
+        OffchainItemContent,
+    ]:
+        method_result = await NFTItemGetMethods.get_nft_data(
+            client=self.client,
+            address=self.address,
+        )
+        content_cs: Slice = method_result[4].begin_parse()
+        return (
+            bool(method_result[0]),
+            method_result[1],
+            method_result[2],
+            method_result[3],
+            OffchainItemContent.deserialize(content_cs),
+        )
+
+
+class NFTItemStandard(BaseNFTItem[DStandard, C]):
+    _data_model = NFTItemStandardData
+    VERSION = NFTItemVersion.NFTItemStandard
+
+
+class NFTItemEditable(BaseNFTItem[DEditable, C]):
+    _data_model = NFTItemEditableData
+    VERSION = NFTItemVersion.NFTItemStandard
+
+    @property
+    def editor_address(self) -> Address:
+        return self.state_data.editor_address
+
+    async def get_editor_address(self) -> t.Optional[Address]:
+        return await NFTItemGetMethods.get_editor(
+            client=self.client,
+            address=self.address,
+        )
+
+
+class NFTItemSoulbound(BaseNFTItem[DSoulbound, C]):
+    _data_model = NFTItemSoulboundData
+    VERSION = NFTItemVersion.NFTItemStandard
+
+    @property
+    def authority_address(self) -> t.Optional[Address]:
+        return self.state_data.authority_address
+
+    @property
+    def revoked_at(self) -> int:
+        return self.state_data.revoked_at
+
+    async def get_authority_address(self) -> t.Optional[Address]:
+        return await NFTItemGetMethods.get_authority_address(
+            client=self.client,
+            address=self.address,
+        )
+
+    async def get_revoked_time(self) -> int:
+        return await NFTItemGetMethods.get_revoked_time(
+            client=self.client,
+            address=self.address,
+        )

tonutils/contracts/wallet/__init__.py

@@ -0,0 +1,39 @@
+from .base import BaseWallet
+from .get_methods import WalletGetMethods
+
+from .versions import (
+    WalletHighloadV2,
+    WalletHighloadV3R1,
+    WalletPreprocessedV2,
+    WalletV1R1,
+    WalletV1R2,
+    WalletV1R3,
+    WalletV2R1,
+    WalletV2R2,
+    WalletV3R1,
+    WalletV3R2,
+    WalletV4R1,
+    WalletV4R2,
+    WalletV5Beta,
+    WalletV5R1,
+)
+
+__all__ = [
+    "BaseWallet",
+    "WalletGetMethods",
+    "WalletHighloadV2",
+    "WalletHighloadV3R1",
+    "WalletPreprocessedV2",
+    "WalletV1R1",
+    "WalletV1R2",
+    "WalletV1R3",
+    "WalletV2R1",
+    "WalletV2R2",
+    "WalletV3R1",
+    "WalletV3R2",
+    "WalletV4R1",
+    "WalletV4R2",
+    "WalletV5Beta",
+    "WalletV5R1",
+    "get_methods",
+]

tonutils/contracts/wallet/base.py

@@ -0,0 +1,300 @@
+from __future__ import annotations
+
+import abc
+import typing as t
+
+from pytoniq_core import (
+    Cell,
+    WalletMessage,
+    StateInit,
+    begin_cell,
+    Address,
+)
+from pytoniq_core.crypto.keys import (
+    mnemonic_to_private_key,
+    mnemonic_new,
+)
+from pytoniq_core.crypto.signature import sign_message
+
+from ..base import BaseContract
+from ..codes import CONTRACT_CODES
+from ...exceptions import (
+    ContractError,
+)
+from ...protocols import (
+    ClientProtocol,
+    WalletProtocol,
+)
+from ...types import (
+    AddressLike,
+    BaseWalletConfig,
+    BaseWalletData,
+    BaseWalletParams,
+    PrivateKey,
+    PublicKey,
+    SendMode,
+    TransferJettonMessage,
+    TransferMessage,
+    TransferNFTMessage,
+    WorkchainID,
+    ContractStateInfo,
+)
+from ...utils import (
+    VALID_MNEMONIC_LENGTHS,
+    build_external_msg_any,
+    normalize_hash,
+    validate_mnemonic,
+    to_cell,
+)
+
+D = t.TypeVar("D", bound=BaseWalletData)
+C = t.TypeVar("C", bound=BaseWalletConfig)
+P = t.TypeVar("P", bound=BaseWalletParams)
+
+TWallet = t.TypeVar("TWallet", bound="BaseWallet[t.Any, t.Any, t.Any]")
+
+
+class BaseWallet(BaseContract, WalletProtocol[D, C, P], abc.ABC):
+    _data_model: t.Type[D]
+    _config_model: t.Type[C]
+    _params_model: t.Type[P]
+
+    MAX_MESSAGES: t.ClassVar[int]
+
+    def __init__(
+        self,
+        client: ClientProtocol,
+        address: Address,
+        state_init: t.Optional[StateInit] = None,
+        state_info: t.Optional[ContractStateInfo] = None,
+        config: t.Optional[C] = None,
+        private_key: t.Optional[PrivateKey] = None,
+    ) -> None:
+        self._config = config
+        self._private_key: t.Optional[PrivateKey] = None
+        self._public_key: t.Optional[PublicKey] = None
+
+        if private_key is not None:
+            self._private_key = private_key
+            self._public_key = private_key.public_key
+        super().__init__(client, address, state_init, state_info)
+
+    @property
+    def state_data(self) -> D:
+        return super().state_data
+
+    @property
+    def config(self) -> C:
+        return t.cast(C, self._config)
+
+    @property
+    def public_key(self) -> t.Optional[PublicKey]:
+        return self._public_key if self._public_key else None
+
+    @property
+    def private_key(self) -> t.Optional[PrivateKey]:
+        return self._private_key if self._private_key else None
+
+    @abc.abstractmethod
+    async def _build_msg_cell(
+        self,
+        messages: t.List[WalletMessage],
+        params: t.Optional[P] = None,
+    ) -> Cell: ...
+
+    async def _build_sign_msg_cell(
+        self,
+        signing_msg: Cell,
+        signature: bytes,
+    ) -> Cell:
+        cell = begin_cell()
+        cell.store_bytes(signature)
+        cell.store_cell(signing_msg)
+        return cell.end_cell()
+
+    async def _build_signed_msg_cell(
+        self,
+        messages: t.List[WalletMessage],
+        params: t.Optional[P] = None,
+    ) -> Cell:
+        if self._private_key is None:
+            raise ContractError(
+                self,
+                f"Cannot sign message: "
+                f"`private_key` is not set for wallet `{self.VERSION.value}`.",
+            )
+        signed_msg = await self._build_msg_cell(messages, params)
+        signature = sign_message(signed_msg.hash, self._private_key.keypair.bytes)
+        return await self._build_sign_msg_cell(signed_msg, signature)
+
+    @classmethod
+    def from_private_key(
+        cls: t.Type[TWallet],
+        client: ClientProtocol,
+        private_key: PrivateKey,
+        workchain: WorkchainID = WorkchainID.BASECHAIN,
+        config: t.Optional[C] = None,
+    ) -> TWallet:
+        config = config or cls._config_model()
+        cls._validate_config_type(config)
+        config.public_key = private_key.public_key
+
+        code = to_cell(CONTRACT_CODES[cls.VERSION])
+        data = cls._data_model(**config.to_dict()).serialize()
+
+        state_init = StateInit(code=code, data=data)
+        address = Address((workchain.value, state_init.serialize().hash))
+        return cls(client, address, state_init, None, config, private_key)
+
+    @classmethod
+    def from_mnemonic(
+        cls: t.Type[TWallet],
+        client: ClientProtocol,
+        mnemonic: t.Union[t.List[str], str],
+        validate: bool = True,
+        workchain: WorkchainID = WorkchainID.BASECHAIN,
+        config: t.Optional[C] = None,
+    ) -> t.Tuple[TWallet, PublicKey, PrivateKey, t.List[str]]:
+        if isinstance(mnemonic, str):
+            mnemonic = mnemonic.strip().lower().split()
+        if validate:
+            validate_mnemonic(mnemonic)
+
+        pub_key_bytes, priv_key_bytes = mnemonic_to_private_key(mnemonic)
+        private_key = PrivateKey(priv_key_bytes)
+        public_key = PublicKey(pub_key_bytes)
+
+        wallet = cls.from_private_key(client, private_key, workchain, config)
+        return wallet, public_key, private_key, mnemonic
+
+    @classmethod
+    def create(
+        cls: t.Type[TWallet],
+        client: ClientProtocol,
+        mnemonic_length: int = 24,
+        workchain: WorkchainID = WorkchainID.BASECHAIN,
+        config: t.Optional[C] = None,
+    ) -> t.Tuple[TWallet, PublicKey, PrivateKey, t.List[str]]:
+        cls._validate_mnemonic_length(mnemonic_length)
+        mnemonic = mnemonic_new(mnemonic_length)
+        return cls.from_mnemonic(client, mnemonic, True, workchain, config)
+
+    async def raw_transfer(
+        self,
+        messages: t.List[WalletMessage],
+        params: t.Optional[P] = None,
+    ) -> str:
+        await self.refresh()
+        self._validate_message_count(messages)
+        self._validate_params_type(params)
+
+        body = await self._build_signed_msg_cell(messages, params)
+        state_init = self.state_init if not self.is_active else None
+
+        msg = build_external_msg_any(
+            dest=self.address,
+            body=body,
+            state_init=state_init,
+        )
+        msg_boc = msg.serialize().to_boc().hex()
+        normalized_hash = normalize_hash(msg)
+
+        await self.client.send_boc(msg_boc)
+        return normalized_hash
+
+    async def transfer(
+        self,
+        destination: AddressLike,
+        value: int,
+        body: t.Optional[t.Union[Cell, str]] = None,
+        state_init: t.Optional[StateInit] = None,
+        send_mode: t.Optional[t.Union[SendMode, int]] = None,
+        bounce: t.Optional[bool] = None,
+        params: t.Optional[P] = None,
+    ) -> str:
+        message = TransferMessage(
+            destination=destination,
+            value=value,
+            body=body,
+            state_init=state_init,
+            send_mode=send_mode,
+            bounce=bounce,
+        )
+        return await self.transfer_message(message, params)
+
+    async def transfer_message(
+        self,
+        message: t.Union[
+            TransferMessage,
+            TransferNFTMessage,
+            TransferJettonMessage,
+        ],
+        params: t.Optional[P] = None,
+    ) -> str:
+        message = await message.to_wallet_msg(self)
+        return await self.raw_transfer([message], params)
+
+    async def batch_transfer_message(
+        self,
+        messages: t.List[
+            t.Union[
+                TransferMessage,
+                TransferNFTMessage,
+                TransferJettonMessage,
+            ]
+        ],
+        params: t.Optional[P] = None,
+    ) -> str:
+        messages = [await m.to_wallet_msg(self) for m in messages]
+        return await self.raw_transfer(messages, params)
+
+    @classmethod
+    def _validate_config_type(
+        cls: t.Type[TWallet],
+        config: C,
+    ) -> None:
+        if not isinstance(config, cls._config_model):
+            raise ContractError(
+                cls,
+                f"Invalid contract config type for `{cls.VERSION.value}`. "
+                f"Expected {cls._config_model.__name__}, "
+                f"got {type(config).__name__}.",
+            )
+
+    @classmethod
+    def _validate_params_type(
+        cls: t.Type[TWallet],
+        params: t.Optional[P] = None,
+    ) -> None:
+        if params is not None and not isinstance(params, cls._params_model):
+            raise ContractError(
+                cls,
+                f"Invalid params type for `{cls.VERSION.value}`. "
+                f"Expected {cls._params_model.__name__}, "
+                f"got {type(params).__name__ if params is not None else 'None'}.",
+            )
+
+    @classmethod
+    def _validate_message_count(
+        cls: t.Type[TWallet],
+        messages: t.List[WalletMessage],
+    ) -> None:
+        if len(messages) > cls.MAX_MESSAGES:
+            raise ContractError(
+                cls.__name__,
+                f"For `{cls.VERSION.value}`, "
+                f"maximum messages amount is {cls.MAX_MESSAGES}, "
+                f"but got {len(messages)}.",
+            )
+
+    @classmethod
+    def _validate_mnemonic_length(
+        cls: t.Type[TWallet],
+        mnemonic_length: int,
+    ) -> None:
+        if mnemonic_length not in VALID_MNEMONIC_LENGTHS:
+            raise ContractError(
+                cls,
+                f"Invalid mnemonic length: {mnemonic_length}. "
+                f"Expected one of {VALID_MNEMONIC_LENGTHS}.",
+            )