python-sdk/thirdweb/core/classes/contract_deployer.py at a88774191c83961ef4a2aa900872065d7a3ef76f · thirdweb-dev/python-sdk · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
from typing import Any, Dict, Optional

from web3 import Web3
from eth_account.account import LocalAccount
from thirdweb.constants.addresses import get_contract_address_by_chain_id
from thirdweb.constants.chains import ChainId
from thirdweb.core.classes.factory import ContractFactory
from thirdweb.core.classes.ipfs_storage import IpfsStorage
from thirdweb.core.classes.provider_handler import ProviderHandler
from thirdweb.core.classes.registry import ContractRegistry
from thirdweb.types.contract import ContractType
from thirdweb.types.sdk import SDKOptions
from thirdweb.types.settings.metadata import (
    EditionDropContractMetadata,
    MultiwrapContractMetadata,
    NFTDropContractMetadata,
    EditionContractMetadata,
    MarketplaceContractMetadata,
    NFTCollectionContractMetadata,
    TokenContractMetadata,
    TokenDropContractMetadata,
)


class ContractDeployer(ProviderHandler):
    __factory: ContractFactory
    __registry: ContractRegistry

    _storage: IpfsStorage

    def __init__(
        self,
        provider: Web3,
        signer: Optional[LocalAccount] = None,
        options: SDKOptions = SDKOptions(),
        storage: IpfsStorage = IpfsStorage(),
    ):
        super().__init__(provider, signer, options)
        self._storage = storage

    def deploy_nft_collection(self, metadata: NFTCollectionContractMetadata) -> str:
        """
        Deploy an NFT Collection contract.
        """

        return self._deploy_contract(ContractType.NFT_COLLECTION, metadata.to_json())

    def deploy_edition(self, metadata: EditionContractMetadata) -> str:
        """
        Deploy an Edition contract
        """

        return self._deploy_contract(ContractType.EDITION, metadata.to_json())

    def deploy_token(self, metadata: TokenContractMetadata) -> str:
        """
        Deploy a Token contract
        """

        return self._deploy_contract(ContractType.TOKEN, metadata.to_json())

    def deploy_marketplace(self, metadata: MarketplaceContractMetadata) -> str:
        """
        Deploy a Marketplace contract
        """

        return self._deploy_contract(ContractType.MARKETPLACE, metadata.to_json())

    def deploy_nft_drop(self, metadata: NFTDropContractMetadata) -> str:
        """
        Deploy an NFT Drop contract
        """

        return self._deploy_contract(ContractType.NFT_DROP, metadata.to_json())

    def deploy_edition_drop(self, metadata: EditionDropContractMetadata) -> str:
        """
        Deploy an Edition Drop contract
        """

        return self._deploy_contract(ContractType.EDITION_DROP, metadata.to_json())

    def deploy_token_drop(self, metadata: TokenDropContractMetadata) -> str:
        """
        Deploy a Token Drop contract
        """

        return self._deploy_contract(ContractType.TOKEN_DROP, metadata.to_json())

    def deploy_multiwrap(self, metadata: MultiwrapContractMetadata) -> str:
        """
        Deploy a Multiwrap contract
        """

        return self._deploy_contract(ContractType.MULTIWRAP, metadata.to_json())

    def _deploy_contract(
        self, contract_type: ContractType, contract_metadata: Dict[str, Any]
    ) -> str:
        factory = self._get_factory()
        return factory.deploy(contract_type, contract_metadata)

    def _get_registry(self) -> ContractRegistry:
        try:
            return self.__registry
        except:
            pass

        chain_id = ChainId(self.get_provider().eth.chain_id)
        registry_address = get_contract_address_by_chain_id(chain_id, "tw_registry")

        self.__registry = ContractRegistry(
            registry_address,
            self.get_provider(),
            self.get_signer(),
            self.get_options(),
        )

        return self.__registry

    def _get_factory(self) -> ContractFactory:
        try:
            return self.__factory
        except:
            pass

        chain_id = ChainId(self.get_provider().eth.chain_id)
        factory_address = get_contract_address_by_chain_id(chain_id, "tw_factory")

        self.__factory = ContractFactory(
            factory_address,
            self.get_provider(),
            self.get_signer(),
            self.get_options(),
            self._storage,
        )

        return self.__factory