def _deploy_cps_score(self, to: str = SCORE_INSTALL_ADDRESS, params=None) -> dict: if params is None: params = {} transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.CPS_SCORE_PROJECT)) \ .params(params) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) # process the transaction in local tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertEqual(True, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) pprint(tx_result) return tx_result
def _deploy_smart_wallet(wallet, token_type, contract_addr, sendLimit, dids): deploy_contract = gen_deploy_data_content("../smart_wallet") print(deploy_contract) account = { "tokenType": token_type, "contractAddr": contract_addr, "balance": 0, "totalUsed": 0, "sendLimit": int(sendLimit), "lastUsedDate": "2018-11-12", "dids": dids } transaction = DeployTransactionBuilder() \ .from_(wallet.get_address()) \ .to("cx0000000000000000000000000000000000000000") \ .step_limit(2000000000000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(deploy_contract) \ .params({"account": json.dumps(account)}) \ .build() result = _send_transaction(transaction, wallet, 10) IconServiceContainer.contract_addr = result['scoreAddress']
def _deploy_score(self, to: str = SCORE_INSTALL_ADDRESS) -> dict: dir_path = os.path.abspath(os.path.dirname(__file__)) score_project = os.path.abspath(os.path.join(dir_path, '..')) score_content_bytes = gen_deploy_data_content(score_project) # Generates an instance of transaction for deploying SCORE. transaction = DeployTransactionBuilder() \ .from_(self._wallet.get_address()) \ .to(to) \ .nid(3) \ .step_limit(10000000000) \ .nonce(100) \ .content_type("application/zip") \ .content(score_content_bytes) \ .params({}) \ .build() # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, self._wallet) # process the transaction in local tx_result = self.process_transaction(signed_transaction, self._icon_service) self.assertEqual(True, tx_result['status'], msg=pp.pformat(tx_result)) self.assertTrue('scoreAddress' in tx_result, msg=pp.pformat(tx_result)) return tx_result
def _deploy_score( self, to: str = SCORE_INSTALL_ADDRESS ) -> dict: #SCORE 배포를위한 트랜잭션 인스턴스를 생성합니다. transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.SCORE_PROJECT)) \ .build() signed_transaction = SignedTransaction( transaction, self._test1) # 서명이있는 서명 된 트랜잭션 객체를 반환합니다. # 로컬에서 거래 처리 tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertTrue('status' in tx_result) self.assertEqual(1, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) return tx_result
def _deploy_irc2(self, project, to: str = SCORE_INSTALL_ADDRESS) -> dict: # Generates an instance of transaction for deploying SCORE. transaction = DeployTransactionBuilder() \ .params({ "_initialSupply": 0x100000000000, "_decimals": 18, "_name": 'StandardToken', "_symbol": 'ST', }) \ .from_(self._operator.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(project)) \ .build() # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, self._operator) # process the transaction in local result = self.process_transaction(signed_transaction, self.icon_service) self.assertTrue('status' in result) self.assertEqual(1, result['status']) self.assertTrue('scoreAddress' in result) return result
def _deploy_score(self, to: str = SCORE_INSTALL_ADDRESS, params: dict = None) -> dict: # Generates an instance of transaction for deploying SCORE. transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.SCORE_PROJECT)) \ .params(params) \ .build() # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, self._test1) # process the transaction tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertTrue('status' in tx_result) self.assertEqual(1, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) return tx_result
def _deploy_score(self, to: str = SCORE_INSTALL_ADDRESS) -> dict: # publish token score contract transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100).params(self.TOKEN_SCORE_PARAM) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.TOKEN_SCORE_PROJECT)) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertTrue('status' in tx_result) self.assertEqual(1, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) # publish crowdsale score contract self.CROWDSALE_PARAM['_tokenScore'] = tx_result['scoreAddress'] transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100).params(self.CROWDSALE_PARAM) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.CROWDSALE_SCORE_PROJECT)) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertTrue('status' in tx_result) self.assertEqual(1, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) return { 'crowdsale_score_address': tx_result['scoreAddress'], 'token_score_address': self.CROWDSALE_PARAM['_tokenScore'] }
def test_in_memory_zip(self): current_dir_path = path.abspath(path.dirname(__file__)) score_path = path.join(current_dir_path, 'sample_token') tests_path = path.join(current_dir_path, 'sample_token', 'tests') # bytes of sample_token's content content_bytes = gen_deploy_data_content(score_path) content_bytes_as_str = str(content_bytes) self.assertFalse( 'test_integrate_sample_token.py' in content_bytes_as_str) self.assertFalse(tests_path[1:] in content_bytes_as_str) self.assertTrue(score_path[1:] in content_bytes_as_str)
def _deploy_score(self, to: str = SCORE_INSTALL_ADDRESS) -> dict: transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.SCORE_PROJECT)) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) tx_result = self.process_transaction(signed_transaction) return tx_result
def test_update_scores(self): score_list = ['cps_score', 'cpf_treasury', 'cps_treasury'] transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(self.contracts[score_list[0]]) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.CPS_SCORE_PROJECT)) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) tx_hash = self.process_transaction(signed_transaction, self.icon_service) pprint(tx_hash)
def create_deploy_score_tx( score_path: str, from_: 'KeyWallet', to: str = SCORE_INSTALL_ADDRESS) -> 'SignedTransaction': transaction = DeployTransactionBuilder() \ .from_(from_.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(DEFAULT_NID) \ .nonce(0) \ .content_type("application/zip") \ .content(gen_deploy_data_content(score_path)) \ .build() # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, from_) return signed_transaction
def _deploy_std_basic(self, to: str = SCORE_INSTALL_ADDRESS) -> dict: # Generates an instance of transaction for deploying SCORE. transaction = (DeployTransactionBuilder().from_( self._test1.get_address()).to(to).step_limit(100_000_000_000).nid( 3).nonce(100).content_type("application/zip").content( gen_deploy_data_content(self.STD_BASIC_PROJECT)).build()) # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, self._test1) # process the transaction in local tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertEqual(True, tx_result["status"]) self.assertTrue("scoreAddress" in tx_result) return tx_result
def update(self, score_path: str, step_limit: int, estimate: bool) -> str: """Update governance SCORE :return: tx_hash """ path: str = os.path.join(score_path, "package.json") if not os.path.isfile(path): raise Exception(f"Invalid score path: {score_path}") content: bytes = gen_deploy_data_content(score_path) tx_handler = self._create_tx_handler() ret = tx_handler.update(self._owner, GOVERNANCE_ADDRESS, content, step_limit=step_limit, estimate=estimate) return ret
def update_contracts(self, contract_path: str, contract_address: str): transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(contract_address) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(contract_path)) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) # process the transaction in local tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertEqual(True, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) return tx_result
def _deploy_score( self, key_wallet: 'KeyWallet', path: str, score_address: str = SYSTEM_ADDRESS, ) -> dict: # Generates an instance of transaction for deploying SCORE. transaction = DeployTransactionBuilder() \ .from_(key_wallet.get_address()) \ .to(score_address) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(path)) \ .build() # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, key_wallet) # send transaction return self.icon_service.send_transaction(signed_transaction)
def test_deploy_sICX_score(self, to=SCORE_INSTALL_ADDRESS): params = {'_admin': self.contracts['staking_score']} transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.sICX_SCORE)) \ .params(params) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) # process the transaction in local tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertEqual(True, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) pprint(tx_result) return tx_result
def deploy_contract(self, contract_info, account_info): wallet = KeyWallet.load(bytes.fromhex(account_info['wallet_key'])) contract_content_bytes = gen_deploy_data_content( contract_info['contract_file']) deploy_transaction = DeployTransactionBuilder() \ .from_(wallet.get_address()) \ .to(SCORE_INSTALL_ADDRESS) \ .step_limit(self.get_max_step_limit(wallet.get_address())) \ .nid(self.network_id) \ .nonce(self.network_id) \ .content_type('application/zip') \ .content(contract_content_bytes) \ .params(contract_info['params']) \ .version(self.network_id) \ .build() signed_transaction = SignedTransaction(deploy_transaction, wallet) tx_hash = self.icon_service.send_transaction(signed_transaction) # print('tx_hash:', tx_hash) tx_result = self.get_transaction_result(tx_hash) return tx_result
def _deploy_score(self, to: str = SCORE_INSTALL_ADDRESS) -> dict: # SCORE deploy하기 위한 transaction instance를 만든다 transaction = DeployTransactionBuilder() \ .from_(self._test.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .nonce(100) \ .content_type("application/zip") \ .content(gen_deploy_data_content(self.SCORE_PROJECT)) \ .build() # signature 를 가진 signed transaction 리턴한다 signed_transaction = SignedTransaction(transaction, self._test) # 로컬에서 transaction process 한다 tx_result = self.process_transaction(signed_transaction) self.assertTrue('status' in tx_result) self.assertEqual(1, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) return tx_result
def _deploy_score(self, scorepath: str, to: str = SCORE_INSTALL_ADDRESS, _params: dict = None) -> dict: transaction = DeployTransactionBuilder() \ .from_(self._test1.get_address()) \ .to(to) \ .step_limit(100_000_000_000) \ .nid(3) \ .content_type("application/zip") \ .content(gen_deploy_data_content(scorepath)) \ .params(_params) \ .build() signed_transaction = SignedTransaction(transaction, self._test1) tx_result = self.process_transaction(signed_transaction, self.icon_service) self.assertTrue('status' in tx_result) self.assertEqual(1, tx_result['status']) self.assertTrue('scoreAddress' in tx_result) return tx_result
def deployJoinScore(wallet: KeyWallet, icon_service: IconService, proccess_tx_fn) -> dict: dir_path = os.path.abspath(os.path.dirname(__file__)) score_project = os.path.abspath(os.path.join(dir_path, '..')) score_content_bytes = gen_deploy_data_content(score_project) # Generates an instance of transaction for deploying SCORE. transaction = DeployTransactionBuilder() \ .from_(wallet.get_address()) \ .to(SCORE_INSTALL_ADDRESS) \ .nid(3) \ .step_limit(10000000000) \ .nonce(100) \ .content_type("application/zip") \ .content(score_content_bytes) \ .params({}) \ .build() # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(transaction, wallet) # process the transaction in local tx_result = proccess_tx_fn(signed_transaction, icon_service) return tx_result
def get_score_content(target: str): score_path = f"./contracts/{target}" return gen_deploy_data_content(score_path)
def deploy(self, conf: dict) -> dict: """Deploy SCORE on the server. :param conf: deploy command configuration """ # check keystore, and get password from user's terminal input password = conf.get('password', None) password = self._check_deploy(conf, password) if conf['mode'] == 'install': score_address = f'cx{"0"*40}' else: score_address = conf['to'] uri, version = uri_parser(conf['uri']) icon_service = IconService(HTTPProvider(uri, version)) if password: try: wallet = KeyWallet.load(conf['keyStore'], password) from_ = wallet.get_address() except KeyStoreException as e: print(e.args[0]) return None else: # make dummy wallet wallet = KeyWallet.create() from_ = conf['from'] # make zip and convert to hexadecimal string data (start with 0x) and return content = gen_deploy_data_content(conf['project']) deploy_transaction = DeployTransactionBuilder() \ .from_(from_) \ .to(score_address) \ .nid(convert_hex_str_to_int(conf['nid'])) \ .content_type("application/zip") \ .content(content) \ .params(conf.get('scoreParams', {})) \ .build() if 'stepLimit' not in conf: step_limit = icon_service.estimate_step(deploy_transaction) + 10000 else: step_limit = convert_hex_str_to_int(conf['stepLimit']) deploy_transaction.step_limit = step_limit # Returns the signed transaction object having a signature signed_transaction = SignedTransaction(deploy_transaction, wallet) if not password: signed_transaction.signed_transaction_dict['signature'] = 'sig' # Sends transaction and return response response = send_transaction_with_logger(icon_service, signed_transaction, uri) if 'error' in response: print('Got an error response') print(json.dumps(response, indent=4)) else: print('Send deploy request successfully.') tx_hash = response['result'] print( f'If you want to check SCORE deployed successfully, execute txresult command' ) print(f"transaction hash: {tx_hash}") return response
# Returns the max step limit def get_max_step_limit(): _param = {"context_type": "invoke"} _call = CallBuilder()\ .from_(wallet1.get_address())\ .to(GOVERNANCE_ADDRESS)\ .method("getMaxStepLimit")\ .params(_param)\ .build() _result = icon_service.call(_call) return convert_hex_str_to_int(_result) for score_path in score_paths: # Reads the zip file 'standard_token.zip' and returns bytes of the file install_content_bytes = gen_deploy_data_content(score_path) # Loads a wallet from a key store file wallet1 = KeyWallet.load(TEST_PRIVATE_KEY) print("=" * 100) print("[wallet1] address: ", wallet1.get_address(), " private key: ", wallet1.get_private_key()) # Enters transaction information deploy_transaction = DeployTransactionBuilder()\ .from_(wallet1.get_address())\ .to(SCORE_INSTALL_ADDRESS) \ .step_limit(get_max_step_limit())\ .nid(3)\ .nonce(3)\ .content_type("application/zip")\ .content(install_content_bytes)\
def get_token_content(): token_score_path = path.join("./score", "sampleToken.zip") return gen_deploy_data_content(token_score_path)
.nonce(4) \ .method("scrooge")\ .params(params)\ .build() signed_transaction = SignedTransaction(call_transaction, wallet) tx_hash = icon_service.send_transaction(signed_transaction) print(tx_hash) print(get_tx(tx_hash)) # 1. DeployTransactionBuilder transaction = DeployTransactionBuilder()\ .from_(wallet.get_address())\ .step_limit(100_000_000_000)\ .to("cx0000000000000000000000000000000000000000")\ .nid(3)\ .nonce(100)\ .content_type("application/zip")\ .content(gen_deploy_data_content(SCORE_PROJECT)) \ .params("")\ .build() signed_transaction = SignedTransaction(transaction, wallet) tx_hash = icon_service.send_transaction(signed_transaction) print(tx_hash) score_address = get_tx_result() # 2. CallBuilder call_score_method_welcome(score_address) # 3. CallTransactionBuilder transaction_scrooge(score_address)