def _deploy_score(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.SCORE_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.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
self.assertTrue('scoreAddress' in tx_result)
return tx_result
def setUpClass(cls):
super().setUpClass()
param = {"init_supply": 10000}
deploy_transaction = DeployTransactionBuilder() \
.from_(cls.setting["from"]) \
.to(cls.setting["to_install"]) \
.step_limit(cls.setting["step_limit"]) \
.nid(cls.setting["nid"]) \
.nonce(cls.setting["nonce"]) \
.content_type(cls.setting["content_type"]) \
.content(cls.setting["content_install"]) \
.params(param) \
.version(3) \
.build()
# Test install SCORE : Sends transaction which makes the SCORE install correctly
signed_transaction_dict = SignedTransaction(deploy_transaction,
cls.wallet)
tx_result = cls.icon_service.send_transaction(signed_transaction_dict)
sleep(2)
cls.tx_hash = tx_result
def main():
cmd_args = sys.argv[1:]
parser = get_parser()
args = vars(parser.parse_args(cmd_args))
command = args.get('command')
url = args.get('url')
step_limit = int(args.get('stepLimit', 0))
nid = int(args.get('nid', 0))
icon_service = IconService(HTTPProvider(url))
try:
if command == 'register':
wallet = get_wallet(args)
json_path = args.get('json')
with open(json_path, mode='r') as prep_info:
reg_info = json.load(prep_info)
public_key = wallet.bytes_public_key
reg_info['publicKey'] = f"0x{public_key.hex()}"
register_fee: int = 2000 * 10 ** 18
tx = CallTransactionBuilder(). \
from_(wallet.get_address()). \
to(ZERO_ADDRESS). \
step_limit(step_limit). \
value(register_fee). \
nid(nid). \
nonce(100). \
method("registerPRep"). \
params(reg_info). \
build()
signed_data = SignedTransaction(tx, wallet)
result = icon_service.send_transaction(signed_data)
elif command == 'unregister':
wallet = get_wallet(args)
params = {}
if args.get('address'):
params['address'] = args['address']
tx = CallTransactionBuilder().from_(wallet.get_address()).to(ZERO_ADDRESS). \
step_limit(step_limit).nid(nid).nonce(100).method("unregisterPRep").\
params(params).value(0).build()
signed_data = SignedTransaction(tx, wallet)
result = icon_service.send_transaction(signed_data)
elif command == 'preps':
json_path = args.get('json')
if json_path is not None:
with open(json_path, mode='r') as prep_info:
params = json.load(prep_info)
else:
params = {}
call_data = CallBuilder(from_=f"hx{'0'*40}", to=ZERO_ADDRESS,
method="getPReps").params(params).build()
result = icon_service.call(call_data)
else:
print('unknown command')
sys.exit(2)
print('result : ', result)
return 0
except BaseException as e:
print(e)
sys.exit(3)
def test_transfer_from_approved(self):
# Mint an NFT token first via 'mint'
params = {'_to': self._test1.get_address(), '_tokenId': 1}
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(100_000_000) \
.method("mint") \
.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'])
# Approve token operation to new wallet via 'approve'
params = {'_to': self._wallet_array[0].get_address(), '_tokenId': 1}
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(100_000_000) \
.method("approve") \
.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'])
# Check approval of token 1 via 'getApproval'
# owner of token 1 should be self._test1
# approvee of token 1 should be self._wallet_array[0]
params = {"_tokenId": 1}
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("getApproved") \
.params(params) \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(response, self._wallet_array[0].get_address())
# Transfer ownership of token 1 from self._test1 to self._wallet_array[1] by its operator approvee self._wall_array[0] using 'transferFrom'
params = {
'_from': self._test1.get_address(),
'_to': self._wallet_array[1].get_address(),
'_tokenId': 1
}
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(100_000_000) \
.method("transferFrom") \
.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'])
# Check new ownership of token 1, expected to be self._wallet_array[1]
params = {"_tokenId": 1}
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("ownerOf") \
.params(params) \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(response, self._wallet_array[1].get_address())
# Check token 1's new approved operator, expected zero address
params = {"_tokenId": 1}
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("getApproved") \
.params(params) \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(
response, str(Address.from_prefix_and_int(AddressPrefix.EOA, 0)))
# Check token count of self._test1, expected 0
params = {"_owner": self._test1.get_address()}
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params) \
.build()
response = self.process_call(call, self.icon_service)
self.assertEqual(response, hex(0))
# Last we burn the token from the new owner self._wallet_array[1]
params = {
"_tokenId": 1,
}
transaction = CallTransactionBuilder() \
.from_(self._wallet_array[1].get_address()) \
.to(self._score_address) \
.step_limit(100_000_000) \
.method("burn") \
.params(params) \
.build()
signed_transaction = SignedTransaction(transaction,
self._wallet_array[1])
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
# Check owner of token 1, expect invalid owner (zero address)
params = {"_tokenId": 1}
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("ownerOf") \
.params(params) \
.build()
with self.assertRaises(IconScoreException) as e:
self.process_call(call, self.icon_service)
self.assertEqual(e.exception.code, 32)
self.assertEqual(e.exception.message,
"Invalid _tokenId. NFT is burned")
def test_transaction(self):
self.logger.info('Start transfer transaction...')
_user_wallet = self._wallet_array[1]
_remote_wallet = self._wallet_array[2]
_to = self._wallet_array[3]
self._transfer_token(self._test1, _user_wallet, True)
self._transfer_token(self._test1, _remote_wallet, True)
self._transfer_token(self._test1, _to, True)
#self._transfer_token(_remote_wallet, self._test1, False)
response = self._call_balance(_user_wallet.get_address())
self.logger.info("BALANCE [%s] : %s" %
(_user_wallet.get_address(), int(response, 16)))
response = self._call_balance(_remote_wallet.get_address())
self.logger.info("BALANCE [%s] : %s" %
(_remote_wallet.get_address(), int(response, 16)))
response = self._call_balance(_to.get_address())
self.logger.info("BALANCE [%s] : %s" %
(_to.get_address(), int(response, 16)))
self.logger.info('Token Transfer Transaction Build ...')
value = 100
params = {
'_from': _user_wallet.get_address(),
'_to': _to.get_address(),
'_value': value
}
transaction = CallTransactionBuilder() \
.from_(_user_wallet.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transfer") \
.params(params) \
.build()
signedTransaction = SignedTransaction(transaction, _user_wallet)
data = json.dumps(transaction.to_dict(),
sort_keys=True,
indent=4,
separators=(',', ': '))
self.logger.debug(f'Inner TX Data : {data}')
data = json.dumps(signedTransaction.signed_transaction_dict,
sort_keys=True,
indent=4,
separators=(',', ': '))
self.logger.debug(f'Inner TX Signed Data : {data}')
self.logger.info('Remote Excute Transaction Build ...')
params = {
'_data': f'{signedTransaction.signed_transaction_dict}'.encode()
}
transaction = CallTransactionBuilder() \
.from_(_remote_wallet.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("remotetx") \
.params(params) \
.build()
signed_transaction = SignedTransaction(transaction, _remote_wallet)
self.logger.info('Excute Transaction ...')
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.logger.debug('TX RESULT : %s' % tx_result)
response = self._call_balance(_user_wallet.get_address())
self.logger.info("BALANCE [%s] : %s" %
(_user_wallet.get_address(), int(response, 16)))
response = self._call_balance(_remote_wallet.get_address())
self.logger.info("BALANCE [%s] : %s" %
(_remote_wallet.get_address(), int(response, 16)))
response = self._call_balance(_to.get_address())
self.logger.info("BALANCE [%s] : %s" %
(_to.get_address(), int(response, 16)))
def test_remove_blacklist_by_owner(self):
print('------ Remove Blacklist by owner start -----')
# Make params of add_blacklist method
to = self.non_owner_wallet.get_address()
value = 100
params = {
'addr': to,
}
# Generates an instance of transaction for calling method in SCORE.
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("add_blacklist") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# Sends the transaction to the network
print('Add blacklist by owner', 'From:', self._test1.get_address(),
'Address:', to)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
# Checkwhitelist
params = {'addr': to}
# Generates a call instance using the CallBuilder
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("check_blacklist") \
.params(params) \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
print('BlackList status of ', to, 'Status:', response)
params = {
'addr': to,
}
# Generates an instance of transaction for calling method in SCORE.
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("remove_blacklist") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# Sends the transaction to the network
print('Remove blacklist by owner', 'From:', self._test1.get_address(),
'Address:', to)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
# Checkwhitelist
params = {'addr': to}
# Generates a call instance using the CallBuilder
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("check_blacklist") \
.params(params) \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
print('BlackList status of ', to, 'Status:', response)
to = self._wallet_array[0].get_address()
value = 100
params = {
'_to': to,
'_value': value,
}
# Generates an instance of transaction for calling method in SCORE.
transaction = CallTransactionBuilder() \
.from_(self.non_owner_wallet.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transfer") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction,
self.non_owner_wallet)
# Sends the transaction to the network
print('Transfer Transaction', value, 'From:',
self.non_owner_wallet.get_address(), 'To:', to)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertEqual(tx_result['status'], 0)
self.assertFalse(tx_result['failure'] is None)
print('\t(Transaction Reverted)', tx_result['failure']['message'])
print('------ Remove Blacklist by owner end -----')
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)\
.version(3)\
.build()
# Returns the signed transaction object having a signature
signed_transaction_dict = SignedTransaction(deploy_transaction, wallet1)
# Sends the transaction
tx_hash = icon_service.send_transaction(signed_transaction_dict)
print("txHash: ", tx_hash)
@retry(JSONRPCException, tries=10, delay=1, back_off=2)
def get_tx_result():
# Returns the result of a transaction by transaction hash
tx_result = icon_service.get_transaction_result(tx_hash)
print("transaction status(1:success, 0:failure): ",
tx_result["status"])
print("score address: ", tx_result["scoreAddress"])
print("waiting a second for accepting score...\n")
get_tx_result()
header = "This timestamp of " + str(url) + " was taken at " + str(utc_datetime) + " UTC." + "\n\n"
header_hex = header.encode("utf-8").hex()
tx_message = header_hex + html_hex
#Calculate transaction message length
tx_message_length = len(tx_message)
if tx_message_length > 509950:
print("Sorry, this HTML page is too large to timestamp in an ICX transaction.")
exit()
elif tx_message_length <= 509950:
keystore_location = input("What is the file path of your keystore file? ")
keystore_password = input("What is your keystore password? ")
keystore_location_str = keystore_location.rstrip()
keystore_password_str = keystore_password.rstrip()
#Create ICX transaction
wallet = KeyWallet.load(keystore_location_str, keystore_password_str)
transaction = MessageTransactionBuilder()\
.from_(wallet.get_address())\
.to(wallet.get_address())\
.step_limit(100000000)\
.data("0x" + tx_message)\
.nid(1)\
.build()
icon_service = IconService(HTTPProvider("https://wallet.icon.foundation/api/v3"))
signed_transaction = SignedTransaction(transaction, wallet)
tx_hash = icon_service.send_transaction(signed_transaction)
#Print success message with link to transaction on ICON tracker
print("\nSuccess! View your timestamped HTML at the URL below.\nhttps://tracker.icon.foundation/transaction/" + tx_hash + "\n")
def test_deploy_integrate(self):
"""
Integrate-test for deploying SCORE
1. Installs a SCORE named SampleToken.
2. Checks if making an instance of installing SCORE transaction correctly.
*** It needs about 1 sec to build consensus.
3. Sends a call Transaction which calls a method `acceptScore` to make the new SCORE active
4. Updates the SCORE having added methods
5. Checks if making an instance of updating SCORE transaction correctly.
*** It needs about 1 sec to build consensus.
6. Sends a call transaction which calls a method `acceptScore` to make the updated SCORE active
7. Calls a querying method `hello` of the updated SCORE
8. Calls a querying method `total_supply` of the updated SCORE
9. Calls a invoking method `transfer` of the updated SCORE
"""
# Test install SCORE : Checks if making an instance of deploy transaction correctly
param = {"init_supply": 10000}
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to_install"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_install"]) \
.params(param) \
.version(3) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Test install SCORE : Sends transaction which makes the SCORE install correctly
signed_transaction_dict = SignedTransaction(deploy_transaction,
self.wallet)
result_install = self.icon_service.send_transaction(
signed_transaction_dict)
self.assertTrue(is_T_HASH(result_install))
# Test install SCORE : Sends a call transaction calling a method `acceptScore` to make the SCORE active
params = {"txHash": result_install}
call_transaction = CallTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to_governance"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.method("acceptScore") \
.params(params) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(call_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# Test update SCORE : Checks if making an instance of deploy transaction correctly
sleep(2)
installed_score_address = self.icon_service.get_transaction_result(
result_install)["scoreAddress"]
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_update"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Test update SCORE : Sends transaction which makes the SCORE update correctly
signed_transaction_dict = SignedTransaction(deploy_transaction,
self.wallet)
result_update = self.icon_service.send_transaction(
signed_transaction_dict)
self.assertTrue(is_T_HASH(result_update))
# Test update SCORE : Sends a call transaction calling a method `acceptScore` to make the SCORE active
params = {"txHash": result_update}
call_transaction = CallTransactionBuilder().from_(self.setting["from"]).to(self.setting["to_governance"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).method("acceptScore").params(
params).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(call_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# Test update SCORE : Calls a method `hello` of the updated SCORE
sleep(2)
call_transaction = CallBuilder().from_(self.setting["from"]).to(installed_score_address) \
.method("hello").build()
result = self.icon_service.call(call_transaction)
self.assertEqual(result, "Hello")
# Test update SCORE : Calls a method `total_supply` of the updated SCORE
call_transaction = CallBuilder().from_(self.setting["from"]).to(installed_score_address) \
.method("total_supply").build()
result = self.icon_service.call(call_transaction)
self.assertEqual(result, "0x0")
# Test call a invoking method of SCORE
value = "0x1"
params = {
"addr_to": "hxab2d8215eab14bc6bdd8bfb2c8151257032ecd8b",
"value": value
}
call_transaction = CallTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.method("transfer") \
.params(params) \
.nid(self.setting["nid"]) \
.step_limit(self.setting["step_limit"]) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
call_transaction)
self.assertTrue(is_call_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(call_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
def test_transfer(self):
# When having an optional property, nonce
icx_transaction = TransactionBuilder()\
.from_(self.setting["from"])\
.to(self.setting["to"]) \
.value(self.setting["value"])\
.step_limit(self.setting["step_limit"])\
.nid(3) \
.nonce(self.setting["nonce"])\
.version(3) \
.build()
tx_dict = SignedTransaction.to_dict(icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# When not having an optional property, nonce
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).build()
tx_dict = SignedTransaction.to_dict(icx_transaction)
self.assertTrue(is_icx_transaction(tx_dict))
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# When value is wrong prefixed with '0x'
wrong_value = "0x34330000000"
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(wrong_value).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
self.assertRaises(DataTypeException, SignedTransaction,
icx_transaction, self.wallet)
# When value is valid which type is int
wrong_value = 34330000000
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(wrong_value).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
# When address is wrong
wrong_address = "hx5bfdb090f43a808005ffc27c25b213145e8"
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(wrong_address) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction,
signed_transaction_dict)
# When not having a required property, nid
icx_transaction = TransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction,
signed_transaction_dict)
# When a sending address is wrong - not the wallet's address
wrong_address = "hx5bfdb090f43a808005ffc27c25b213145e80b7cd"
icx_transaction = TransactionBuilder().from_(wrong_address).to(self.setting["to"]) \
.value(self.setting["value"]).step_limit(self.setting["step_limit"]).nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]).build()
signed_transaction_dict = SignedTransaction(icx_transaction,
self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction,
signed_transaction_dict)
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
def test_deposit_add_and_withdraw(self):
# Test install SCORE : Checks if making an instance of deploy transaction correctly
param = {"init_supply": 10000}
deploy_transaction = DeployTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to_install"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.content_type(self.setting["content_type"]) \
.content(self.setting["content_install"]) \
.params(param) \
.version(3) \
.build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(
deploy_transaction)
self.assertTrue(is_deploy_transaction(tx_dict))
# Test install SCORE : Sends transaction which makes the SCORE install correctly
signed_transaction_dict = SignedTransaction(deploy_transaction,
self.wallet)
result_install = self.icon_service.send_transaction(
signed_transaction_dict)
self.assertTrue(is_T_HASH(result_install))
sleep(2)
installed_score_address = self.icon_service.get_transaction_result(
result_install)["scoreAddress"]
_DEPOSIT_AMOUNT = 5000 * (10**18)
deposit_transaction_of_add_0: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.value(_DEPOSIT_AMOUNT) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.action("add") \
.build()
# Checks if sending transaction correctly
signed_transaction_dict = SignedTransaction(
deposit_transaction_of_add_0, self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
sleep(2)
self.assertEqual(
self.icon_service.get_transaction_result(result)["status"], 1)
# transaction instance for withdraw action
deposit_transaction_of_withdraw: DepositTransaction = DepositTransactionBuilder() \
.from_(self.setting["from"]) \
.to(installed_score_address) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.id(result) \
.action("withdraw") \
.build()
signed_transaction_dict = SignedTransaction(
deposit_transaction_of_withdraw, self.wallet)
result = self.icon_service.send_transaction(signed_transaction_dict)
self.assertTrue(is_T_HASH(result))
sleep(2)
self.assertEqual(
self.icon_service.get_transaction_result(result)["status"], 1)
def test_auction_sell(self):
################### TEST_TOKEN ADD ###################
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("init_add") \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
params = {"_playerId": 1, "_price": 1}
transaction = CallTransactionBuilder() \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("auction_sell") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
response = self.process_transaction(signed_transaction,
self.icon_service)
print("auction_sell : ", response)
params = {"_tokenId": 0}
call_balanceOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("getApproved") \
.params(params) \
.build()
response = self.process_call(call_balanceOf, self.icon_service)
print("getApproved : ", response)
params = {
"_to": "hx08711b77e894c3509c78efbf9b62a85a4354c8df",
"_tokenId": 0
}
################ buy 성공하면 스코어가 바이한테 approve하기
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("approve") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
response = self.process_transaction(signed_transaction,
self.icon_service)
print("approve2 : ", response)
params = {"_tokenId": 0}
call_balanceOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("getApproved") \
.params(params) \
.build()
response = self.process_call(call_balanceOf, self.icon_service)
print("getApproved : ", response)
# 구매할때 메소드 따로 처리하고
params = {"_playerId": 1}
transaction = CallTransactionBuilder() \
.from_("hx08711b77e894c3509c78efbf9b62a85a4354c8df") \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("auction_buy") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
response = self.process_transaction(signed_transaction,
self.icon_service)
print("auction_buy : ", response)
params = {
"_from": "hxe7af5fcfd8dfc67530a01a0e403882687528dfcb",
"_to": "hx08711b77e894c3509c78efbf9b62a85a4354c8df",
"_tokenId": 0
}
transaction = CallTransactionBuilder() \
.from_(self._score_address) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transferFrom") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
response = self.process_transaction(signed_transaction,
self.icon_service)
print("transferFrom : ", response)
params = {"_tokenId": 0}
call_balanceOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("ownerOf") \
.params(params) \
.build()
response = self.process_call(call_balanceOf, self.icon_service)
print("ownerOf : ", response)
def test_transferFrom(self):
################### TEST_TOKEN ADD ###################
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("init_add") \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
####################################################
################### TEST BALANCEOF ###################
params = {
"_owner": "hxe7af5fcfd8dfc67530a01a0e403882687528dfcb",
}
call_ownerOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params) \
.build()
response = self.process_call(call_ownerOf, self.icon_service)
print("balanceOf : ", response)
####################################################
params = {
"_to": "hxe7af5fcfd8dfc67530a01a0e403882687528dfcb",
"_tokenId": 2,
}
transaction = CallTransactionBuilder() \
.from_("hx08711b77e894c3509c78efbf9b62a85a4354c8df") \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("approve") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
####################################################
################### TEST TRANSFERFROM ###################
params = {
"_from": "hx08711b77e894c3509c78efbf9b62a85a4354c8df",
"_to": "hxe7af5fcfd8dfc67530a01a0e403882687528dfcb",
"_tokenId": 2,
}
transaction = CallTransactionBuilder() \
.from_("hx79e7f88e6186e72d86a1b3f1c4e29bd4ae00ff53") \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transferFrom") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
####################################################
################### TEST TRANSFER ###################
params = {
"_tokenId": 1,
}
call_ownerOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("ownerOf") \
.params(params) \
.build()
response = self.process_call(call_ownerOf, self.icon_service)
print("token_owner : ", response)
####################################################
################### TEST BALANCEOF ###################
params = {
"_owner": "hxe7af5fcfd8dfc67530a01a0e403882687528dfcb",
}
call_ownerOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params) \
.build()
response = self.process_call(call_ownerOf, self.icon_service)
print("balanceOf : ", response)
def test_approve(self):
################### TEST_TOKEN ADD ###################
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("init_add") \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
params = {
"_to": "hx08711b77e894c3509c78efbf9b62a85a4354c8df",
"_tokenId": 1,
}
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("approve") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# print("signed_transaction: ", signed_transaction)
self.process_transaction(signed_transaction, self.icon_service)
params = {
"_tokenId": 1,
}
call_ownerOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("getApproved") \
.params(params) \
.build()
response = self.process_call(call_ownerOf, self.icon_service)
print("getApproved : ", response)
params = {
"_owner": self._test1.get_address()
# "_owner":"hx08711b77e894c3509c78efbf9b62a85a4354c8df"
}
call_balanceOf = CallBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params) \
.build()
response = self.process_call(call_balanceOf, self.icon_service)
print("balanceOf : ", response)
def dice_bot(next_bet, loss_streak, bet_count):
# Checks for integer or float bet amount and converts it
if isinstance(next_bet, int):
next_bet = int_to_bigint(next_bet)
else:
next_bet = float_value(next_bet)
# Params for the contract call. You can write a lucky phrase in user_seed if you want to.
params = {
"upper": hex(upper),
"lower": hex(lower),
"user_seed": ""
}
transaction = CallTransactionBuilder() \
.from_(wallet.get_address()) \
.to(testnet) \
.step_limit(40000000) \
.value(next_bet) \
.nid(nid) \
.nonce(50) \
.method("call_bet") \
.params(params) \
.build()
# Signs and sends the tx to the contract
signed_transaction = SignedTransaction(transaction, wallet)
tx_hash = icon_service.send_transaction(signed_transaction)
# Important to put some delay to get the result of your bet. 4sec is enough but its better to put some bigger number
time.sleep(wait_time)
tx_result = icon_service.get_transaction_result(tx_hash)
my_bet_range = tx_result["eventLogs"][3]["indexed"]
my_bet_range = sorted([from_hex(dice) for dice in my_bet_range[2:]])
bet_result = tx_result["eventLogs"][4]["indexed"]
winning_number = from_hex(bet_result[2])
# You can change the bet amounts after a loss streak or return to your base bet.
bet_value = [0.2, 0.8, 1.6, 3.2]
# A counter checks for number of lose streaks, changing the bet and reseting after a win.
if lower <= winning_number <= upper:
bet_count += 1
loss_streak = 0
print(
f"\tWIN \t\t\t\t{icx_balance:6.2f}\t\t\t\t{from_bigint(next_bet):5.2f}\t\t\t\t\t\t{winning_number:2}\
\t\t\t{my_bet_range[0]:2}-{my_bet_range[1]:2}\t\t\t\t{bet_counter:4}\t\t\t{tx_hash}")
next_bet = bet_value[0]
else:
loss_streak += 1
bet_count += 1
if loss_streak == 1:
print(
f"\tLOSS(x1)\t\t\t\t{icx_balance:6.2f}\t\t\t\t{from_bigint(next_bet):5.2f}\t\t\t\t\t\t{winning_number:2}\
\t\t\t{my_bet_range[0]:2}-{my_bet_range[1]:2}\t\t\t\t{bet_counter:4}\t\t\t{tx_hash}")
next_bet = bet_value[1]
elif loss_streak == 2:
print(
f"\tLOSS(X2)\t\t\t{icx_balance:6.2f}\t\t\t\t{from_bigint(next_bet):5.2f}\t\t\t\t\t\t{winning_number:2}\
\t\t\t{my_bet_range[0]:2}-{my_bet_range[1]:2}\t\t\t\t{bet_counter:4}\t\t\t{tx_hash}")
next_bet = bet_value[2]
elif loss_streak == 3:
print(
f"\tLOSS(X3)\t\t\t{icx_balance:6.2f}\t\t\t\t{from_bigint(next_bet):5.2f}\t\t\t\t\t\t{winning_number:2}\
\t\t\t{my_bet_range[0]:2}-{my_bet_range[1]:2}\t\t\t{bet_counter:4}\t\t\t{tx_hash}")
next_bet = bet_value[3]
else:
print("REKT : Bot exits")
exit()
return next_bet, loss_streak, bet_count
def _send_transaction(self, transaction) -> dict:
signed_tx = SignedTransaction(transaction, self._wallet)
tx_hash = self._icon_service.send_transaction(signed_tx)
sleep(SLEEP_TIMER)
return self.get_tx_result_by_hash(tx_hash)
class calltransaction_transaction_RT():
#python 내에 calltransaction_transaction_RT 이라는 클래스를 선언해준다.
start_time = time.time()
#시작시간을 측정하기위해 만듦 start_time변수 안에 time함수를 사용하여 시간을 저장
now = datetime.datetime.now()
#now라는 변수안에 현재 날짜와 시간을 대입
nowDate = now.strftime('%Y%m%d')
#nowDate 현재 날짜를 구분하기위해 변수선언한후 now변수에 저장된 시간들을 갖고오는데 %년%월%일만 가져와서 저장
nowTime = now.strftime('%H%M')
#nowTime에 현재시각을 대입하기위해 %시간 %분을 대입해준다
#DB에 들어가게 될 데이터 값으로 Local 타임존 값을 지정해 준다.
localnow = datetime.datetime.now(timezone('Asia/Seoul'))
localnowDate = localnow.strftime('%Y%m%d')
html = requests.get('https://www.naver.com/').text
#html이란 변수에 beautifulsoup을 사용하여 요청하여 얻어온다 naver를 text형식으로
soup = BeautifulSoup(html, 'html.parser')
#무엇을이 여기서 결정된다 soup에 beautifulsoup을 사용하여 html에 저장된 것을 parser해온다
#parser란 구문분석이란 의미로 인터넷소스들을 끌어온다
title_list = soup.select(
'.PM_CL_realtimeKeyword_rolling span[class*=ah_k]')
#title_list안에 soup에 저장된 값들중에 select 선택하겠다. ()안의 값들만 골라오겠다
#()안의 값은 네이버소스에서 직접검색하면 찾아볼수 있다.
Machined_title_list = list()
#Machined_Google_title_list라는 리스트를 선언해준다
for idx, title in enumerate(title_list, 1):
Machined_title_list.append(title.text)
#for문에 idx(순서)와 title(새로운변수)을 돌리는데 enumerate(숫자를세다) title_list를
#그리고 그값을 Machined_Google_title_list에 하나씩 append}(리스트에 삽입시킨다 title.text를)
naver_list = Machined_title_list[0:5]
#네이버 순위를 5개만 갖고오기 위한 작업
print(naver_list)
params = {
"_date": nowDate,
"_time": nowTime,
"_div": 'NAVER',
"_value": json.dumps(naver_list)
}
#params 란 스코어와 sdk관계에서 값들을 넘겨줄 매게변수를 설정해주는 값을 정해줄 수 있는 것 이라고 생각하면쉽다
#그렇기에 키값으로 들어갈 것들과 위에서 리스트로 정리할 값을 json 형식으로 묶어서 보낸다
transaction = CallTransactionBuilder() \
.from_(_keystore_address) \
.to(_score_address) \
.step_limit(10_000_000) \
.nid(1) \
.nonce(100) \
.method("transaction_RT") \
.params(params) \
.build()
#스코어와 연동시킬 CallTransactionBuilder()를 transaction에 넣을건데 그밑의 값들을 넣을 것이다 라는 의미이다.
'''
from_ : 거래를 수행하는 지갑 주소. 기본 주소는 귀하의 계정 주소입니다.
to : 거래를 받기 위해 동전이나 SCORE 주소를받는 지갑 주소
step_limit : 트랜잭션 처리를위한 최대 단계 값
nid : 네트워크 ID. 값을 설정하지 않으면 기본 nid는 1입니다. (주망 1 등)
nonce : 트랜잭션 해시 충돌을 방지하는 데 사용되는 임의의 숫자
method : SCORE의 메소드
params : SCORE 메서드에 전달 된 매개 변수입니다. 매개 변수의 데이터 유형은 dict 여야합니다 . (선택 과목)
버전 : 프로토콜 버전 (V3의 경우 3). 값을 설정하지 않은 경우 기본 버전은 3입니다.
timestamp : 트랜잭션 생성 시간. 시간 소인은 마이크로 초입니다. 값을 설정하지 않으면 기본 타임 스탬프가 설정됩니다.
Build : 호출 트랜잭션 객체를 반환합니다.
'''
#print(nowDate, nowTime, 'NAVER')
signed_transaction = SignedTransaction(transaction, wallet)
#SignedTransaction(transaction: Transaction, wallet: Wallet)
#transaction : 아직 서명 필드가없는 트랜잭션 객체
tx_hash = icon_service.send_transaction(signed_transaction)
# print(tx_hash)
time.sleep(5)
# tx_result = icon_service.get_transaction_result(tx_hash)
# print(tx_result['status'])
#print("--- %s seconds ---" % (time.time() - start_time))
#---------------------------------------------GOOGLE----------------------------------------
options = webdriver.ChromeOptions()
options.add_argument('headless')
options.add_argument('window-size=1920x1080')
options.add_argument("disable-gpu")
#위의 옵션들은 selenium을쓸때 아래에서 구글브라우저를 열때 자동으로 닫히게 해주는 옵션들이다 이외에 다른옵션들도 많다
path = "/usr/local/bin/chromedriver" #"/home/ubuntu/Downloads/chromedriver"
#이전에 chromedriver을 압축해제한 곳의 경로를 path 변수에 저장시킨다
driver = webdriver.Chrome(path, chrome_options=options)
time.sleep(5)
#dirver 안에 path라는 경로에 있는 크롬 웹드라이버를 대입
driver.get(
"https://trends.google.com/trends/trendingsearches/realtime?geo=US&category=all"
)
#driver.get("url") 구글 개발자모드안에 소스에서 xpath로 검색해오면 된다. 위 드라이브로 get 얻어오겠다 가로안의 url 의 값을
time.sleep(5)
req = driver.page_source
#req안에 driver로 얻어온 page_source를 넣어준다
soup = BeautifulSoup(req, 'html.parser')
#soup안에 Beautifulsoup으로 (req에 저장된 값을 파싱시킨다 html.parser)
title_list = soup.select('div > span:nth-child(1) > a')
#셀레니움 드라이버 종료
driver.quit()
'''
그리고 title_list에 soup안에 저장내용중에 select 선택해온다
(div > span:nth-child(1) > a)
자신이 갖고오고 싶은 소스 값들을 개발자모드에서 selector 해오면
해당값들이 복사되어 온다
'''
Temp_list = title_list[0:5]
Machined_Google_title_list = list()
for title in Temp_list:
Machined_Google_title_list.append(title.text.strip())
print(Machined_Google_title_list)
params_G = {
"_date": nowDate,
"_time": nowTime,
'_div': 'GOOGLE',
"_value": json.dumps(Machined_Google_title_list)
}
transaction_G = CallTransactionBuilder() \
.from_(_keystore_address) \
.to(_score_address) \
.step_limit(10_000_000) \
.nid(1) \
.nonce(100) \
.method("transaction_RT") \
.params(params_G) \
.build()
#print(nowDate, nowTime, 'GOOGLE')
signed_transaction_G = SignedTransaction(transaction_G, wallet)
tx_hash_G = icon_service.send_transaction(signed_transaction_G)
#send_transaction(signed_transaction: SignedTransaction)
#트랜잭션을 보냅니다.
#print("--- %s seconds ---" % (time.time() - start_time))
#------------time sleep-------------------------------------
# print(tx_hash_G)
# time.sleep(10)
# tx_result_G = icon_service.get_transaction_result(tx_hash_G)
# print(tx_result_G['status'])
# ------------------------Google DB Con------------------------
# MySQL Connection 연결
conn = pymysql.connect(host='127.0.0.1',
user='******',
password='******',
db='Crawling_DB',
charset='utf8')
#DB접근을 위한 기능을 객체화 한다, 뒤에 pymysql.cursors.DictCursor은 변수를 통해 동적으로 할당해주기 위한 옵션이다.
curs = conn.cursor(pymysql.cursors.DictCursor)
#5점 부터 1점까지 차례대로 점수를 부여하기 위해 b라는 변수 선언
b = 5
'''
#누락값 DB 저장
# 가지고온 현재 1등 데이터가 TOP20 테이블에 이미 존재하고 있는지 검사 (없다면 누락값을 의심해 볼 수 있음)
# 가지고온 현재 1등 데이터를 check라는 변수에 할당한다.
check = Machined_Google_title_list[0]
#crawling_App_receive_google_data라는 테이블에서 key1 칼럼이 변수 nowDate 값과 일치하고 G_Word 칼럼이 check와 일치하는 값을 가지고 온다
sql = "select * from crawling_App_receive_google_data where key1=%s and G_Word=%s"
curs.execute(sql, (localnowDate, check))
check_resuit = curs.fetchall()
print(check_resuit)
#만약 데이터가 테이블에 존재하지 않으면 missing_data테이블에 값을 입력해준다. (누락값으로 의심되는 값을 의미)
if not check_resuit and int(nowTime) != 0:
sql = "INSERT INTO crawling_App_missing_data (key1,Word,type) VALUES(%s,%s,'G')"
curs.execute(sql, (localnowDate, check))
rows = curs.fetchall()
conn.commit()
'''
# 가져온 20개의 키워드 insert 또는 update
# 첫번째 키워드 부터 스무번째 키워드 까지 순서대로 수행
for a in Machined_Google_title_list:
#insert할지 update할지 구분을 위해 검색된 단어의 점수 존재 여부를 체크하고, 몇점인지 확인한다.
#crawling_App_receive_google_data라는 테이블에서 key1 칼럼이 변수 nowDate 값과 일치하고 G_Word 칼럼이 a와 일치하는 값의 G_Rating를 가져온다.
#조건절에 nowDate 옵션을 주어서 현재 날짜에 있는 데이터로 범위를 제한한다.
sql = "select G_Rating from crawling_App_receive_google_data where key1=%s and G_Word=%s"
curs.execute(sql, (localnowDate, a))
num = curs.fetchall()
#만약 G_Word 값이 존재한다면
if num:
# print("already exist")
#DB에서 가져온 데이터의 첫번째 키워드 부터 스무번째 키워드 까지 순서대로 수행
#기존의 점수 값에서 점수를 더해주는 기능
for x in num:
d = list(x.values())
k = int(d[0])
k = k + b
# 만약 a[0]값이 crawling_receive_google_data에 없으며 주의 메세지 출력
#crawling_App_receive_google_data라는 테이블에서 G_Word 칼럼이 a와 일치하는 값의 G_Rating을 k변수로 업데이트 한다.
sql = "UPDATE crawling_App_receive_google_data SET G_Rating=%s WHERE G_Word=%s"
curs.execute(sql, (k, a))
rows = curs.fetchall()
conn.commit()
#만약 G_Word 값이 존재하지 않는다면
else:
# print("New Input")
#crawling_App_receive_google_data라는 테이블에서 새로운 레코드를 생성한다.(key1 : localnowDate, G_Word : a, G_Rating : b)
sql = "INSERT INTO crawling_App_receive_google_data (key1,G_Word,G_Rating) VALUES(%s,%s,%s)"
curs.execute(sql, (localnowDate, a, b))
rows = curs.fetchall()
conn.commit()
#키워드 순위가 떨어지면 점수도 1점씩 작게 부여하기 위해서 b에서 1을 뺀다.
b = b - 1
# ------------------------Naver DB Con------------------------
#5점 부터 1점까지 차례대로 점수를 부여하기 위해 b라는 변수 선언
b = 5
'''
# 누락값 DB저장
# 가지고온 현재 1등 데이터가 TOP20 테이블에 이미 존재하고 있는지 검사 (없다면 누락값을 의심해 볼 수 있음)
# 가지고온 현재 1등 데이터를 check라는 변수에 할당한다.
check = naver_list[0]
#crawling_App_receive_naver_data라는 테이블에서 key1 칼럼이 변수 nowDate 값과 일치하고 N_Word 칼럼이 check와 일치하는 값을 가지고 온다
sql = "select * from crawling_App_receive_naver_data where key1=%s and N_Word=%s"
curs.execute(sql, (localnowDate, check))
check_resuit = curs.fetchall()
#만약 데이터가 테이블에 존재하지 않으면 missing_data테이블에 값을 입력해준다. (누락값으로 의심되는 값을 의미)
if not check_resuit and int(nowTime) != 0 :
sql = "INSERT INTO crawling_App_missing_data (key1,Word,type) VALUES(%s,%s,'N')"
curs.execute(sql, (localnowDate, check))
rows = curs.fetchall()
conn.commit()
'''
# 가져온 20개의 키워드 insert 또는 update
# 첫번째 키워드 부터 스무번째 키워드 까지 순서대로 수행
for a in naver_list:
#insert할지 update할지 구분을 위해 검색된 단어의 점수 존재 여부를 체크하고, 몇점인지 확인한다.
#crawling_App_receive_naver_data라는 테이블에서 key1 칼럼이 변수 nowDate 값과 일치하고 N_Word 칼럼이 a와 일치하는 값의 N_Rating를 가져온다.
#조건절에 nowDate 옵션을 주어서 현재 날짜에 있는 데이터로 범위를 제한한다.
sql = "select N_Rating from crawling_App_receive_naver_data where key1=%s and N_Word=%s"
curs.execute(sql, (localnowDate, a))
num = curs.fetchall()
#만약 N_Word 값이 존재한다면
if num:
#DB에서 가져온 데이터의 첫번째 키워드 부터 스무번째 키워드 까지 순서대로 수행
#기존의 점수 값에서 점수를 더해주는 기능
for x in num:
d = list(x.values())
k = int(d[0])
k = k + b
#crawling_App_receive_naver_data라는 테이블에서 N_Word 칼럼이 a와 일치하는 값의 N_Rating을 k변수로 업데이트 한다.
sql = "UPDATE crawling_App_receive_naver_data SET N_Rating=%s WHERE N_Word=%s"
curs.execute(sql, (k, a))
rows = curs.fetchall()
conn.commit()
#만약 N_Word 값이 존재하지 않는다면
else:
#crawling_App_receive_naver_data라는 테이블에서 새로운 레코드를 생성한다.(key1 : localnowDate, N_Word : a, N_Rating : b)
sql = "INSERT INTO crawling_App_receive_naver_data (key1,N_Word,N_Rating) VALUES(%s,%s,%s)"
curs.execute(sql, (localnowDate, a, b))
rows = curs.fetchall()
conn.commit()
#키워드 순위가 떨어지면 점수도 1점씩 작게 부여하기 위해서 b에서 1을 뺀다.
b = b - 1
conn.close()
def test_send_message(self):
sleep_time = 2
# Checks if making an instance of message transaction correctly
message_transaction = MessageTransactionBuilder()\
.from_(self.setting["from"])\
.to(self.setting["to"]) \
.step_limit(self.setting["step_limit"])\
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"])\
.data(self.setting["data"]).build()
tx_dict = SignedTransaction.convert_tx_to_jsonrpc_request(message_transaction)
self.assertTrue(is_message_transaction(tx_dict))
# Checks if sending transaction correctly
signed_transaction = SignedTransaction(message_transaction, self.wallet)
result = self.icon_service.send_transaction(signed_transaction)
self.assertTrue(is_T_HASH(result))
# When having an optional property, nonce
sleep(sleep_time)
message_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
result = self.icon_service.send_transaction(signed_transaction)
self.assertTrue(is_T_HASH(result))
# When the data is hex string
sleep(sleep_time)
tx_result = self.icon_service.get_transaction_result(result)
tx = self.icon_service.get_transaction(result)
# Checks the transaction
self.assertEqual(tx["data"], self.setting["data"])
block = self.icon_service.get_block(int(tx_result["blockHeight"]))
# Checks the block's transaction
self.assertEqual(block["confirmed_transaction_list"][0]["data"], self.setting["data"])
# When data is not hex string
message_transaction = MessageTransactionBuilder() \
.from_(self.setting["from"]) \
.to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]) \
.nid(self.setting["nid"]) \
.nonce(self.setting["nonce"]) \
.data("test")
# Raise DataTypeException
self.assertRaises(DataTypeException, message_transaction.build)
# When address is wrong
message_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"][2:]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction, signed_transaction)
# When not having a required property, nid
message_transaction = MessageTransactionBuilder().from_(self.setting["from"]).to(self.setting["to"][2:]) \
.step_limit(self.setting["step_limit"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction, signed_transaction)
# When a sending address is wrong - not the wallet's address
message_transaction = MessageTransactionBuilder().from_(self.setting["to"]).to(self.setting["to"]) \
.step_limit(self.setting["step_limit"]).nid(self.setting["nid"]).data(self.setting["data"]).build()
signed_transaction = SignedTransaction(message_transaction, self.wallet)
self.assertRaises(JSONRPCException, self.icon_service.send_transaction, signed_transaction)
def transfer(self, conf: dict) -> dict:
"""Transfer ICX Coin.
:param conf: transfer command configuration.
:return: response of transfer.
"""
# check value type (must be int), address and keystore file
# if valid, return user input password
password = conf.get('password', None)
password = self._check_transfer(conf, password)
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']
uri, version = uri_parser(conf['uri'])
icon_service = IconService(HTTPProvider(uri, version))
transaction = TransactionBuilder() \
.from_(from_) \
.to(conf['to']) \
.value(int(conf['value'])) \
.nid(convert_hex_str_to_int(conf['nid'])) \
.timestamp(int(time() * 10 ** 6)) \
.build()
if 'stepLimit' not in conf:
step_limit = icon_service.estimate_step(transaction)
else:
step_limit = convert_hex_str_to_int(conf['stepLimit'])
transaction.step_limit = step_limit
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(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 'result' in response:
print('Send transfer request successfully.')
tx_hash = response['result']
print(f"transaction hash: {tx_hash}")
else:
print('Got an error response')
print(json.dumps(response, indent=4))
return response
to_ = to_.get_address()
msg_byte = msg.encode('utf-8')
# build message tx
transaction = MessageTransactionBuilder() \
.from_(from_.get_address()) \
.to(to_) \
.step_limit(step_limit) \
.nid(3) \
.nonce(100) \
.data(f"0x{msg_byte.hex()}") \
.build()
# signing message tx
request = SignedTransaction(transaction, from_)
tx_hashes: list = [network.send_transaction(request)]
sleep(self._block_confirm_interval)
return tx_hashes
def get_txresults(self, network: IconService, tx_hashes: list) -> list:
tx_results: list = []
for h in tx_hashes:
tx_result = network.get_transaction_result(h)
tx_results.append(tx_result)
return tx_results
def mock_calculate(self, _path, _block_height):
context: 'IconScoreContext' = IconScoreContext(
IconScoreContextType.QUERY)
class calltransaction_transaction_RT():
while(1):
# def Crawling_main():
start_time = time.time()
# t = time.time()
# now = time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(t))
# with open('/home/lyu/PycharmProjects/Without_Doubt_Project/Total_Crawler/Time_log.txt', 'a+') as f:
# f.write(now + "\n")
now = datetime.datetime.now()
nowDate = now.strftime('%Y%m%d')
nowTime = now.strftime('%H%M')
html = requests.get('https://www.naver.com/').text
soup = BeautifulSoup(html, 'html.parser')
title_list = soup.select('.PM_CL_realtimeKeyword_rolling span[class*=ah_k]')
Machined_title_list = list()
for idx, title in enumerate(title_list, 1):
Machined_title_list.append(title.text)
print(Machined_title_list)
params = {
"_date": nowDate,
"_time": nowTime,
"_div": 'NAVER',
"_value": json.dumps(Machined_title_list)
}
transaction = CallTransactionBuilder() \
.from_(_keystore_address) \
.to(_score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transaction_RT") \
.params(params) \
.build()
print(nowDate, nowTime, 'NAVER')
signed_transaction = SignedTransaction(transaction, wallet)
tx_hash = icon_service.send_transaction(signed_transaction)
#
# print(tx_hash)
time.sleep(5)
# tx_result = icon_service.get_transaction_result(tx_hash)
# print(tx_result['status'])
print("--- %s seconds ---" % (time.time() - start_time))
#---------------------------------------------GOOGLE----------------------------------------
now = datetime.datetime.now()
# options = webdriver.ChromeOptions()
# options.add_argument('headless')
# options.add_argument('window-size=800x600')
# options.add_argument("disable-gpu")
# path = "/home/lyu/Downloads/chromedriver"
# driver = webdriver.Chrome(path, chrome_options=options)
# driver.get("https://trends.google.com/trends/trendingsearches/realtime?geo=US&category=all")
#
# #driver.find_element_by_xpath('/html/body/div[2]/div[2]/div/div[2]/div/div[2]').click()
# element = driver.find_element_by_css_selector("body > div.trends-wrapper > div:nth-child(2) > div > div.feed-content > div > div.feed-load-more-button")
options = webdriver.ChromeOptions()
options.add_argument('headless')
options.add_argument('window-size=1920x1080')
options.add_argument("disable-gpu")
path = "/home/lyu/Downloads/chromedriver"
driver = webdriver.Chrome(path, chrome_options=options)
driver.get("https://trends.google.com/trends/trendingsearches/realtime?geo=US&category=all")
# driver.find_element_by_xpath('/html/body/div[2]/div[2]/div/div[2]/div/div[2]').click()
element = driver.find_element_by_css_selector("body > div.trends-wrapper > div:nth-child(2) > div > div.feed-content > div > div.feed-load-more-button")
# element.click()
# time.sleep(4)
#element2 = driver.find_element_by_xpath("/html/body/div[2]/div[2]/div/div[2]/div/div[2]")
#print(element)
#print(element2)
req = driver.page_source
soup = BeautifulSoup(req, 'html.parser')
# time.sleep(10)
title_list = soup.select('div > span:nth-child(1) > a')
if ((len(title_list)) <= 20):
element.click()
time.sleep(4)
title_list = soup.select('div > span:nth-child(1) > a')
# shit_list = soup.select('body > div.trends-wrapper > div:nth-child(2) > div > div.feed-content > div > div.feed-load-more-button')
# print(shit_list)
# while not title_list or len(title_list) < 10:
# now = datetime.datetime.now()
# options = webdriver.ChromeOptions()
# options.add_argument('headless')
# options.add_argument('window-size=800x600')
# options.add_argument("disable-gpu")
# path = "/home/lyu/Downloads/chromedriver"
# driver = webdriver.Chrome(path, chrome_options=options)
#
# driver.get("https://trends.google.com/trends/trendingsearches/realtime?geo=US&category=all")
# element = driver.find_element_by_css_selector("body > div.trends-wrapper > div:nth-child(2) > div > div.feed-content > div > div.feed-load-more-button")
# element.click()
# time.sleep(2)
# # element = driver.find_element_by_xpath("body > div.trends-wrapper > div:nth-child(2) > div > div.feed-content > div > div.feed-load-more-button")
# # element2 = driver.find_element_by_xpath("/html/body/div[2]/div[2]/div/div[2]/div/div[2]")
# # print(element)
# # print(element2)
# #driver.find_element_by_xpath('/html/body/div[2]/div[2]/div/div[2]/div/div[2]').click()
# #driver.execute_script("arguments[0].click();", element)
# req = driver.page_source
#
# soup = BeautifulSoup(req, 'html.parser')
# # time.sleep(10)
# title_list = soup.select('div > span:nth-child(1) > a')
Temp_list = title_list[0:20]
Machined_Google_title_list = list()
for title in Temp_list:
Machined_Google_title_list.append(title.text.strip())
print(Machined_Google_title_list)
params_G = {
"_date": nowDate,
"_time": nowTime,
'_div': 'GOOGLE',
"_value": json.dumps(Machined_Google_title_list)
}
transaction_G = CallTransactionBuilder() \
.from_(_keystore_address) \
.to(_score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transaction_RT") \
.params(params_G) \
.build()
print(nowDate, nowTime, 'GOOGLE')
signed_transaction_G = SignedTransaction(transaction_G, wallet)
tx_hash_G = icon_service.send_transaction(signed_transaction_G)
print("--- %s seconds ---" % (time.time() - start_time))
#------------time sleep-------------------------------------
# print(tx_hash_G)
# time.sleep(10)
# tx_result_G = icon_service.get_transaction_result(tx_hash_G)
# print(tx_result_G['status'])
# ------------------------Google DB Con------------------------
# MySQL Connection 연결
conn = pymysql.connect(host='127.0.0.1', user='******', password='******',
db='Crawling_DB', charset='utf8')
# Connection 으로부터 Cursor 생성
# curs = conn.cursor()
curs = conn.cursor(pymysql.cursors.DictCursor)
b = 20
# 현재 1등 데이터가 TOP20 테이블에 이미 존재하고 있는지 검사
check = Machined_Google_title_list[0]
sql = "select * from crawling_App_receive_google_data where key1=%s and G_Word=%s"
curs.execute(sql, (nowDate, check))
check_resuit = curs.fetchall()
if not check_resuit:
print("Warning:%s" %check)
# 가져온 20개의 키워드 insert, update
for a in Machined_Google_title_list:
# orgin score call
# 검색된 단어의 점수가 존재하는 지, 몇점인지 확인한다.
sql = "select G_Rating from crawling_App_receive_google_data where key1=%s and G_Word=%s"
curs.execute(sql, (nowDate, a))
num = curs.fetchall()
if num:
# print("already exist")
for x in num:
d = list(x.values())
k = int(d[0])
k = k + b
# 만약 a[0]값이 crawling_receive_google_data에 없으며 주의 메세지 출력
sql = "UPDATE crawling_App_receive_google_data SET G_Rating=%s WHERE G_Word=%s"
#### 전날 날짜에 업데이트 하게되는 문제
curs.execute(sql, (k, a))
rows = curs.fetchall()
conn.commit()
else:
# print("New Input")
sql = "INSERT INTO crawling_App_receive_google_data (key1,G_Word,G_Rating) VALUES(%s,%s,%s)"
# sql = "select * from crawling_receive_google_data where key1=%s and G_Word='abc' and G_Rating=%s" % (nowDate, b)
curs.execute(sql, (nowDate, a, b))
rows = curs.fetchall()
conn.commit()
b = b - 1
sql = "select G_Word from crawling_App_receive_google_data where key1=%s" % (nowDate)
curs.execute(sql)
rows = curs.fetchall()
print(rows)
# ------------------------Naver DB Con------------------------
b=20
check = Machined_title_list[0]
sql = "select * from crawling_App_receive_naver_data where key1=%s and N_Word=%s"
curs.execute(sql, (nowDate, check))
check_resuit = curs.fetchall()
if not check_resuit:
print("Warning!!!")
# 가져온 20개의 키워드 insert, update
for a in Machined_title_list:
# orgin score call
# 검색된 단어의 점수가 존재하는 지, 몇점인지 확인한다.
sql = "select N_Rating from crawling_App_receive_naver_data where key1=%s and N_Word=%s"
curs.execute(sql, (nowDate, a))
num = curs.fetchall()
if num:
# print("already exist")
for x in num:
d = list(x.values())
k = int(d[0])
k = k + b
# 만약 a[0]값이 crawling_receive_google_data에 없으며 주의 메세지 출력
sql = "UPDATE crawling_App_receive_naver_data SET N_Rating=%s WHERE N_Word=%s"
#### 전날 날짜에 업데이트 하게되는 문제
curs.execute(sql, (k, a))
rows = curs.fetchall()
conn.commit()
else:
# print("New Input")
sql = "INSERT INTO crawling_App_receive_naver_data (key1,N_Word,N_Rating) VALUES(%s,%s,%s)"
# sql = "select * from crawling_receive_google_data where key1=%s and G_Word='abc' and G_Rating=%s" % (nowDate, b)
curs.execute(sql, (nowDate, a, b))
rows = curs.fetchall()
conn.commit()
b = b - 1
sql = "select N_Word from crawling_App_receive_naver_data where key1=%s" % (nowDate)
curs.execute(sql)
rows = curs.fetchall()
print(rows)
conn.close()
print("===========================================================================================================================================")
print("start_time", start_time)
k= (time.time() - start_time)
print("--- %s seconds ---" % (time.time() - start_time))
god = int((60 - (time.time() - start_time)))
time.sleep(god)
def test_token_transfer(self):
# Make params of transfer method
to = self._wallet_array[0].get_address()
value = 100
params = {
'_to': to,
'_value': value,
}
# Generates an instance of transaction for calling method in SCORE.
transaction = CallTransactionBuilder() \
.from_(self._test1.get_address()) \
.to(self._score_address) \
.step_limit(10_000_000) \
.nid(3) \
.nonce(100) \
.method("transfer") \
.params(params) \
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(transaction, self._test1)
# Sends the transaction to the network
print('Transfer Transaction', value, 'From:',
self._test1.get_address(), 'To:', to)
tx_result = self.process_transaction(signed_transaction,
self.icon_service)
self.assertTrue('status' in tx_result)
self.assertEqual(1, tx_result['status'])
# Make params of balanceOf method
params = {'_owner': to}
# Generates a call instance using the CallBuilder
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params) \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
# print('Balance Of Receiver:', to, 'in HEX:', response)
balance = int(response, 0)
print('Balance Of Receiver=>', 'Address:', to, 'Balance:', balance)
# check balance of receiver
self.assertEqual(hex(value), response)
# Make params of balanceOf method
params = {'_owner': self._test1.get_address()}
# Generates a call instance using the CallBuilder
call = CallBuilder().from_(self._test1.get_address()) \
.to(self._score_address) \
.method("balanceOf") \
.params(params) \
.build()
# Sends the call request
response = self.process_call(call, self.icon_service)
# print('Balance Of Sender:', self._test1.get_address(), 'in HEX:', response)
balance = int(response, 0)
print('Balance Of Sender =>', 'Address:', self._test1.get_address(),
'Balance:', balance)
# check balance of sender
self.assertEqual(hex(self.initial_supply * 10**self.decimals - value),
response)
def _distribute(self, condition: bool = True):
tx = self._build_transaction(method="distribute", margin=100000000000)
tx_result = self.process_transaction(
SignedTransaction(tx, self._wallet), self._icon_service)
self.assertEqual(condition, tx_result["status"])
return tx_result
params = {"_to": wallet2.get_address(), "_value": 10}
# Enters transaction information.
call_transaction = CallTransactionBuilder()\
.from_(wallet1.get_address())\
.to(SCORE_ADDRESS) \
.step_limit(get_default_step_cost()*2)\
.nid(3) \
.nonce(4) \
.method("transfer")\
.params(params)\
.build()
# Returns the signed transaction object having a signature
signed_transaction = SignedTransaction(call_transaction, wallet1)
# Reads params to transfer to nodes
print("params:")
pprint(signed_transaction.signed_transaction_dict)
# Sends transaction
tx_hash = icon_service.send_transaction(signed_transaction)
print("txHash: ", tx_hash)
@retry(JSONRPCException, tries=10, delay=1, back_off=2)
def get_tx_result():
# Returns the result of a transaction by transaction hash
tx_result = icon_service.get_transaction_result(tx_hash)
print("transaction status(1:success, 0:failure): ", tx_result["status"])
def _unpause(self):
tx = self._build_transaction(method="unPause", type_="write")
tx_result = self.process_transaction(
SignedTransaction(tx, self._wallet), self._icon_service)
self.assertTrue(tx_result["status"])
return tx_result