def test_store_success(self):
context = self.get_context()
cert, key, _ = PubKeyClient.create_certificate(
context.pub_key_payload, signer=context.client.get_signer())
transaction_signature, cert_address, transaction_payload = self._pre_parse_payload_and_exec(
context, cert, key)
crt_export, crt_bin, crt_sig, rem_sig, pub_key, \
valid_from, valid_to = PubKeyClient.get_crt_export_bin_sig_rem_sig(cert, key, context.client)
account = AccountClient.get_account_model(PUB_KEY_STORE_PRICE)
storage_account = AccountClient.get_account_model(0)
storage_signer = self.get_new_signer()
storage_pub_key = storage_signer.get_public_key().as_hex()
storage_address = AccountHandler().make_address_from_data(
storage_pub_key)
data = PubKeyStorage()
data.owner = self.account_signer1.get_public_key().as_hex()
data.payload.CopyFrom(transaction_payload)
data.revoked = False
self.expect_get({cert_address: None, self.account_address1: account})
self.expect_get({_make_settings_key('remme.economy_enabled'): None})
self.expect_get({
_make_settings_key(SETTINGS_STORAGE_PUB_KEY):
get_setting_from_key_value(SETTINGS_STORAGE_PUB_KEY,
storage_pub_key)
})
self.expect_get({
self.account_address1: account,
storage_address: storage_account
})
context.client.store_pub_key(pub_key, rem_sig, crt_sig, valid_from,
valid_to)
account.balance -= PUB_KEY_STORE_PRICE
account.pub_keys.append(cert_address)
storage_account.balance += PUB_KEY_STORE_PRICE
self.expect_set(
transaction_signature, PubKeyMethod.STORE, {
self.account_address1: account,
cert_address: data,
storage_address: storage_account
})
self.expect_ok()
def test_store_success(self):
context = self.get_context()
cert, key, _ = create_certificate(context.pub_key_payload,
signer=context.client.get_signer())
cert_address, transaction_payload = self._pre_parse_payload_and_exec(
context, cert, key)
crt_export, crt_bin, crt_sig, rem_sig, pub_key, \
valid_from, valid_to = get_crt_export_bin_sig_rem_sig(cert, key, context.client)
account = AccountClient.get_account_model(PUB_KEY_STORE_PRICE)
data = PubKeyStorage()
data.owner = self.account_signer1.get_public_key().as_hex()
data.payload.CopyFrom(transaction_payload)
data.revoked = False
self.expect_get({cert_address: None, self.account_address1: account})
self.expect_get({_make_settings_key('remme.economy_enabled'): None})
context.client.store_pub_key(pub_key, rem_sig, crt_sig, valid_from,
valid_to)
account.balance -= PUB_KEY_STORE_PRICE
account.pub_keys.append(cert_address)
self.expect_set({self.account_address1: account, cert_address: data})
self.expect_ok()
def test_swap_init_success(self):
# Bob init
context = self.get_context()
init_data = {
"receiver_address": self.account_address2,
"sender_address_non_local": context.sender_address_non_local,
"amount": context.AMOUNT,
"swap_id": context.swap_id,
"secret_lock_by_solicitor": context.secret_lock,
"email_address_encrypted_by_initiator": context.email_address,
"created_at": context.created_at,
}
context.client.swap_init(get_swap_init_payload(**init_data))
self.expect_get({context.swap_address: None})
self.expect_get({
_make_settings_key(SETTINGS_SWAP_COMMISSION):
get_setting_from_key_value(SETTINGS_SWAP_COMMISSION, context.COMMISSION)
})
TOTAL_TRANSFERED = context.AMOUNT+context.COMMISSION
self.expect_get({self.account_address1: AccountClient.get_account_model(TOTAL_TRANSFERED)})
updated_state = self.transfer(self.account_address1, TOTAL_TRANSFERED, ZERO_ADDRESS, 0, TOTAL_TRANSFERED)
context.swap_info.state = AtomicSwapInfo.OPENED
self.expect_set({
**{context.swap_address: context.swap_info},
**updated_state
})
self.expect_ok()
def store_pub_key(self, public_key, entity_hash, entity_hash_signature, valid_from, valid_to):
payload = self.get_new_pub_key_payload(public_key,
entity_hash,
entity_hash_signature,
valid_from,
valid_to)
crt_address = self.make_address_from_data(public_key)
account_address = AccountHandler.make_address_from_data(self._signer.get_public_key().as_hex())
settings_address = _make_settings_key('remme.economy_enabled')
addresses_input = [crt_address, account_address, settings_address, self.get_user_address()]
addresses_output = [crt_address, self.get_user_address()]
return self._send_transaction(PubKeyMethod.STORE, payload, addresses_input, addresses_output), crt_address
def swap_init(self, swap_init_payload):
addresses_input = [
self.make_address_from_data(swap_init_payload.swap_id),
self.get_user_address(),
_make_settings_key(SETTINGS_SWAP_COMMISSION),
ZERO_ADDRESS,
CONFIG_ADDRESS,
BLOCK_INFO_NAMESPACE,
]
addresses_output = [
self.make_address_from_data(swap_init_payload.swap_id),
self.get_user_address(),
ZERO_ADDRESS,
]
return self._send_transaction(AtomicSwapMethod.INIT, swap_init_payload,
addresses_input, addresses_output)
TOKENS_AMOUNT_TO_SWAP = 200
BOT_ADDRESS = '112007b9433e1da5c624ff926477141abedfd57585a36590b0a8edc4104ef28093ee30'
BOT_PRIVATE_KEY = '1cb15ecfe1b3dc02df0003ac396037f85b98cf9f99b0beae000dc5e9e8b6dab4'
BOT_PUBLIC_KEY = '03ecc5cb4094eb05319be6c7a63ebf17133d4ffaea48cdcfd1d5fc79dac7db7b6b'
ALICE_PRIVATE_KEY = '8c87d914a6cfeaf027413760ad359b5a56bfe0eda504d879b21872c7dc5b911c'
ALICE_PUBLIC_KEY = '02feb988591c78e58e57cdce5a314bd04798971227fcc2316907355392a2c99c25'
ALICE_ADDRESS = '112007db8a00c010402e2e3a7d03491323e761e0ea612481c518605648ceeb5ed454f7'
SECRET_KEY = '3e0b064c97247732a3b345ce7b2a835d928623cb2871c26db4c2539a38e61a16'
SECRET_LOCK = web3_hash(SECRET_KEY)
SWAP_ID = '033102e41346242476b15a3a7966eb5249271025fc7fb0b37ed3fdb4bcce3884'
ADDRESS_TO_GET_GENESIS_MEMBERS_AS_STRING_BY = _make_settings_key(
SETTINGS_KEY_ZERO_ADDRESS_OWNERS)
ADDRESS_TO_STORE_SWAP_INFO_BY = BasicHandler(
name=AtomicSwapHandler().family_name,
versions=AtomicSwapHandler()._family_versions[0]).make_address_from_data(
data=SWAP_ID)
TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS = {
'family_name': AtomicSwapHandler().family_name,
'family_version': AtomicSwapHandler()._family_versions[0],
}
CURRENT_TIMESTAMP = int(datetime.datetime.now().timestamp())
RANDOM_NODE_PUBLIC_KEY = '039d6881f0a71d05659e1f40b443684b93c7b7c504ea23ea8949ef5216a2236940'
RANDOM_PUBLIC_KEY = '8c87d914a6cfeaf027413760ad359b5a56bfe0eda504d879b21872c7dc5b911c'
RANDOM_ADDRESS = '1120077212221be0a8723c9d9070a047f0623e2933b30666a251523b071735573a099c'
def get_setting_value(self, key):
setting = Setting()
value = self.get_value(_make_settings_key(key))
setting.ParseFromString(value)
return setting.entries[0].value
def swap_init(self, swap_init_payload):
return self._send_transaction(AtomicSwapMethod.INIT, swap_init_payload,
[self.make_address_from_data(swap_init_payload.swap_id),
self.get_user_address(),
ZERO_ADDRESS,
_make_settings_key(SETTINGS_SWAP_COMMISSION)])
def get_pub_key_encryption(self):
setting = Setting()
setting.ParseFromString(self.get_value(_make_settings_key(SETTINGS_PUB_KEY_ENCRYPTION)))
return setting.entries[0].value
async def get_pub_key_encryption(self):
setting = Setting()
pub_key_enc = _make_settings_key(SETTINGS_PUB_KEY_ENCRYPTION)
raw_pub_key = await self.get_value(pub_key_enc)
setting.ParseFromString(raw_pub_key)
return setting.entries[0].value
class RpcApiTestCase(AioHTTPTestCase, HelperTestCase):
@staticmethod
def create_raw_transaction_send_token_payload(pub_key_to, amount=1):
client = AccountClient()
signer = client._signer
address = client.make_address_from_data(pub_key_to)
node_address = client.get_user_address()
transfer = TransferPayload()
transfer.address_to = address
transfer.value = amount
tr = TransactionPayload()
tr.method = AccountMethod.TRANSFER
tr.data = transfer.SerializeToString()
payload = tr.SerializeToString()
header = TransactionHeader(
signer_public_key=signer.get_public_key().as_hex(),
family_name=client._family_handler.family_name,
family_version=client._family_handler.family_versions[-1],
inputs=[node_address, address],
outputs=[node_address, address],
dependencies=[],
payload_sha512=hash512(payload),
batcher_public_key=signer.get_public_key().as_hex(),
nonce=time.time().hex().encode()).SerializeToString()
signature = signer.sign(header)
transaction = Transaction(header=header,
payload=payload,
header_signature=signature)
return transaction
async def get_application(self):
app = web.Application()
rpc = JsonRpc(loop=self.loop, max_workers=1)
rpc.add_methods(
('', get_node_config),
('', send_raw_transaction),
('', get_balance),
('', get_batch_status),
)
app.router.add_route('POST', '/', rpc)
return app
async def create_rpc_request(self, method, params=None):
if params is None:
params = {}
data = encode_request(method, id=int(time.time()), params=params)
LOGGER.info(f'JSON RPC request payload: {data}')
return await self.client.request(
'POST',
'/',
data=data,
headers={'Content-Type': 'application/json'})
@mock.patch(
'remme.clients.basic.BasicClient.fetch_state',
return_value={
'data':
base64.b64encode(
Setting(entries=[
Setting.Entry(
key=_make_settings_key(SETTINGS_STORAGE_PUB_KEY),
value=
'03823c7a9e285246985089824f3aaa51fb8675d08d84b151833ca5febce37ad61e'
)
]).SerializeToString())
})
@mock.patch('remme.clients.basic.BasicClient._head_to_root',
return_value=(None, 'some_root'))
@unittest_run_loop
@test
async def test_node_key_retrieve_info_and_it_ok(self, root_mock,
fetch_state_mock):
resp = await self.create_rpc_request('get_node_config')
self.assertEqual(resp.status, 200)
data = await resp.json()
pub_key = PubKeyClient().get_public_key()
self.assertEqual(data['result']['node_public_key'], pub_key)
@mock.patch(
'remme.clients.basic.BasicClient.submit_batches',
return_value={
'data':
'c6bcb01255c1870a5d42fe2dde5e91fb0c5992ec0b49932cdab901539bf977f75bb7699c053cea16668ba732a7d597dd0c2b80f157f1a2514932078bb761de4b'
})
@unittest_run_loop
@test
async def test_valid_raw_transaction_send_to_the_node(self, req_mock):
payload = self.create_raw_transaction_send_token_payload(
'03823c7a9e285246985089824f3aaa51fb8675d08d84b151833ca5febce37ad61e',
1)
resp = await self.create_rpc_request('send_raw_transaction', {
'data':
base64.b64encode(payload.SerializeToString()).decode('utf-8')
})
self.assertEqual(resp.status, 200)
data = await resp.json()
self.assertEqual(
data['result'],
'c6bcb01255c1870a5d42fe2dde5e91fb0c5992ec0b49932cdab901539bf977f75bb7699c053cea16668ba732a7d597dd0c2b80f157f1a2514932078bb761de4b'
)
@mock.patch('remme.clients.basic.BasicClient.fetch_state',
return_value={
'data':
base64.b64encode(Account(balance=100).SerializeToString())
})
@mock.patch('remme.clients.basic.BasicClient._head_to_root',
return_value=(None, 'some_root'))
@unittest_run_loop
@test
async def test_get_token_balance(self, root_mock, fetch_state_mock):
address = AccountClient().make_address_from_data(
'03823c7a9e285246985089824f3aaa51fb8675d08d84b151833ca5febce37ad61a'
)
resp = await self.create_rpc_request('get_balance',
{'public_key_address': address})
self.assertEqual(resp.status, 200)
data = await resp.json()
self.assertEqual(data['result'], 100)
@mock.patch('remme.clients.basic.BasicClient.list_statuses',
return_value={'data': [{
'status': 'COMMITTED'
}]})
@unittest_run_loop
@test
async def test_check_batch_status(self, batch_status_mock):
resp = await self.create_rpc_request(
'get_batch_status', {
'id':
'3936f0fa13d008c2b00d04013dfa5e5359fccc117e4c47b1416ee24e115ac08b08707be3b3ce6956ca3d789d245ff0dddf7a39bc2b2f4210ffe81ebd0244c014'
})
self.assertEqual(resp.status, 200)
data = await resp.json()
self.assertEqual(data['result'], 'COMMITTED')
TOKENS_AMOUNT_TO_SWAP = 200
SWAP_COMMISSION_AMOUNT = 100
BOT_ETHEREUM_ADDRESS = '0xe6ca0e7c974f06471759e9a05d18b538c5ced11e'
BOT_PRIVATE_KEY = '1cb15ecfe1b3dc02df0003ac396037f85b98cf9f99b0beae000dc5e9e8b6dab4'
BOT_PUBLIC_KEY = '03ecc5cb4094eb05319be6c7a63ebf17133d4ffaea48cdcfd1d5fc79dac7db7b6b'
BOT_ADDRESS = '112007b9433e1da5c624ff926477141abedfd57585a36590b0a8edc4104ef28093ee30'
ALICE_ETHEREUM_ADDRESS = '0x8dfe0f55a1cf9b22b8c85a9ff7a85a28a3879f71'
ALICE_ADDRESS = '112007db8a00c010402e2e3a7d03491323e761e0ea612481c518605648ceeb5ed454f7'
ALICE_EMAIL_ADDRESS_ENCRYPTED_BY_INITIATOR = '0x6f4d5666332f5a575a714d4245624455612f2b4345424f704b4256704f5'
BOT_IT_IS_INITIATOR_MARK = ''
SWAP_ID = '033102e41346242476b15a3a7966eb5249271025fc7fb0b37ed3fdb4bcce3884'
ADDRESS_TO_GET_SWAP_COMMISSION_AMOUNT_BY = _make_settings_key(SETTINGS_SWAP_COMMISSION)
ADDRESS_TO_GET_GENESIS_MEMBERS_AS_STRING_BY = _make_settings_key(SETTINGS_KEY_ZERO_ADDRESS_OWNERS)
ADDRESS_TO_STORE_SWAP_INFO_BY = BasicHandler(
name=AtomicSwapHandler().family_name, versions=AtomicSwapHandler()._family_versions[0]
).make_address_from_data(data=SWAP_ID)
TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS = {
'family_name': AtomicSwapHandler().family_name,
'family_version': AtomicSwapHandler()._family_versions[0],
}
RANDOM_NODE_PUBLIC_KEY = '039d6881f0a71d05659e1f40b443684b93c7b7c504ea23ea8949ef5216a2236940'
RANDOM_PUBLIC_KEY = '8c87d914a6cfeaf027413760ad359b5a56bfe0eda504d879b21872c7dc5b911c'
CURRENT_TIMESTAMP = int(datetime.datetime.now().timestamp())