def get_context(self):
context = super().get_context()
context.AMOUNT = 10000
context.COMMISSION = 100
context.swap_id = generate_random_key()
context.swap_address = AtomicSwapHandler.make_address_from_data(
context.swap_id)
context.secret_key = generate_random_key()
context.secret_lock = hash256(context.secret_key)
context.now = datetime.datetime.now()
context.created_at = int(context.now.timestamp())
context.email_address = ""
context.sender_address_non_local = ""
swap_info = AtomicSwapInfo()
swap_info.swap_id = context.swap_id
swap_info.is_closed = False
swap_info.is_approved = True
swap_info.is_initiator = False
swap_info.amount = context.AMOUNT
swap_info.created_at = context.created_at
swap_info.email_address_encrypted_optional = context.email_address
swap_info.sender_address = self.account_address1
swap_info.sender_address_non_local = context.sender_address_non_local
swap_info.receiver_address = self.account_address2
swap_info.secret_lock = context.secret_lock
context.swap_info = swap_info
return context
def get_context(self):
context = super().get_context()
context.AMOUNT = 10000
context.COMMISSION = 100
context.swap_id = generate_random_key()
context.swap_address = AtomicSwapHandler.make_address_from_data(context.swap_id)
context.secret_key = "039eaa877ff63694f8f09c8034403f8b5165a7418812a642396d5d539f90b170"
context.secret_lock = "b605112c2d7489034bbd7beab083fb65ba02af787786bb5e3d99bb26709f4f68"
context.now = datetime.datetime.now()
context.created_at = int(context.now.timestamp())
context.email_address = ""
context.sender_address_non_local = ""
swap_info = AtomicSwapInfo()
swap_info.swap_id = context.swap_id
swap_info.state = AtomicSwapInfo.OPENED
swap_info.is_initiator = False
swap_info.amount = context.AMOUNT
swap_info.created_at = context.created_at
swap_info.email_address_encrypted_optional = context.email_address
swap_info.sender_address = self.account_address1
swap_info.sender_address_non_local = context.sender_address_non_local
swap_info.receiver_address = self.account_address2
swap_info.secret_lock = context.secret_lock
context.swap_info = swap_info
return context
def _swap_init(self, context, signer_pubkey, swap_init_payload):
"""
if SecretLockOptionalBob is provided, Bob uses _swap_init to respond to requested swap
Otherwise, Alice uses _swap_init to request a swap and thus, Bob can't receive funds until Alice "approves".
"""
address_swap_info_is_stored_by = self.make_address_from_data(swap_init_payload.swap_id)
swap_information = get_data(context, AtomicSwapInfo, address_swap_info_is_stored_by)
if swap_information:
raise InvalidTransaction('Atomic swap ID has already been taken, please use a different one.')
block_info = self._get_latest_block_info(context)
block_time = block_info.timestamp
swap_information = AtomicSwapInfo()
swap_information.swap_id = swap_init_payload.swap_id
swap_information.state = AtomicSwapInfo.OPENED
swap_information.amount = swap_init_payload.amount
swap_information.created_at = block_time
swap_information.secret_lock = swap_init_payload.secret_lock_by_solicitor
swap_information.email_address_encrypted_optional = swap_init_payload.email_address_encrypted_by_initiator
swap_information.sender_address = AccountHandler().make_address_from_data(signer_pubkey)
swap_information.sender_address_non_local = swap_init_payload.sender_address_non_local
swap_information.receiver_address = swap_init_payload.receiver_address
swap_information.is_initiator = not swap_init_payload.secret_lock_by_solicitor
commission_amount = int(_get_setting_value(context, SETTINGS_SWAP_COMMISSION))
if commission_amount < 0:
raise InvalidTransaction('Wrong commission address.')
swap_total_amount = swap_information.amount + commission_amount
account = get_data(context, Account, swap_information.sender_address)
if account is None:
account = Account()
if account.balance < swap_total_amount:
raise InvalidTransaction(
f'Not enough balance to perform the transaction in the amount (with a commission) {swap_total_amount}.'
)
transfer_payload = AccountClient.get_transfer_payload(ZERO_ADDRESS, commission_amount)
transfer_state = AccountHandler()._transfer_from_address(
context, swap_information.sender_address, transfer_payload,
)
sender_account = transfer_state.get(swap_information.sender_address)
sender_account.balance -= swap_information.amount
return {
address_swap_info_is_stored_by: swap_information,
**transfer_state,
}
def _swap_init(self, context, signer_pubkey, swap_init_payload):
"""
if SecretLockOptionalBob is provided, Bob uses _swap_init to respond to requested swap
Otherwise, Alice uses _swap_init to request a swap and thus, Bob can't receive funds until Alice "approves".
"""
LOGGER.info("0. Check if swap ID already exists")
# 0. Check if swap ID already exists
if self.get_swap_info_from_swap_id(context,
swap_init_payload.swap_id,
to_raise_exception=False):
raise InvalidTransaction(
'Atomic swap ID has already been taken, please use a different one!'
)
# END
swap_info = AtomicSwapInfo()
swap_info.swap_id = swap_init_payload.swap_id
swap_info.state = AtomicSwapInfo.OPENED
swap_info.amount = swap_init_payload.amount
swap_info.created_at = swap_init_payload.created_at
swap_info.email_address_encrypted_optional = swap_init_payload.email_address_encrypted_by_initiator
swap_info.sender_address = AccountHandler().make_address_from_data(
signer_pubkey)
swap_info.sender_address_non_local = swap_init_payload.sender_address_non_local
swap_info.receiver_address = swap_init_payload.receiver_address
if not AccountHandler().is_handler_address(swap_info.receiver_address):
raise InvalidTransaction(
'Receiver address is not of a Token type.')
LOGGER.info("1. Ensure transaction initiated within an hour")
# 1. Ensure transaction initiated within an hour
swap_info.secret_lock = swap_init_payload.secret_lock_by_solicitor
created_at = self.get_datetime_from_timestamp(swap_info.created_at)
now = datetime.datetime.utcnow()
if not (now - datetime.timedelta(hours=1) < created_at < now):
raise InvalidTransaction(
'Transaction is created a long time ago or timestamp is assigned set.'
)
# END
LOGGER.info("2. Check weather the sender is Alice")
# 2. Check weather the sender is Alice:
swap_info.is_initiator = not swap_init_payload.secret_lock_by_solicitor
# END
# 3. Transfer funds to zero address.
LOGGER.info("3. Transfer funds to zero address")
commission = int(_get_setting_value(context, SETTINGS_SWAP_COMMISSION))
if commission < 0:
raise InvalidTransaction('Wrong commission address.')
LOGGER.info("4. Get sender's account {}".format(
swap_info.sender_address))
account = get_account_by_address(context, swap_info.sender_address)
total_amount = swap_info.amount + commission
if account.balance < total_amount:
raise InvalidTransaction(
'Not enough balance to perform the transaction in '
'the amount (with a commission) {}.'.format(total_amount))
transfer_payload = AccountClient.get_transfer_payload(
ZERO_ADDRESS, total_amount)
token_updated_state = AccountHandler()._transfer_from_address(
context, swap_info.sender_address, transfer_payload)
LOGGER.info("Save state")
return {**self.get_state_update(swap_info), **token_updated_state}
def test_atomic_swap_init_already_taken_id():
"""
Case: initialize swap of bot's Remme node tokens to Alice's ERC20 Remme tokens with already existing swap id.
Expect: invalid transaction error is raised with atomic swap id has already been taken error message.
"""
atomic_swap_init_payload = AtomicSwapInitPayload(
receiver_address=ALICE_ADDRESS,
sender_address_non_local=BOT_ETHEREUM_ADDRESS,
amount=TOKENS_AMOUNT_TO_SWAP,
swap_id=SWAP_ID,
secret_lock_by_solicitor=BOT_IT_IS_INITIATOR_MARK,
email_address_encrypted_by_initiator=ALICE_EMAIL_ADDRESS_ENCRYPTED_BY_INITIATOR,
created_at=CURRENT_TIMESTAMP,
)
transaction_payload = TransactionPayload()
transaction_payload.method = AtomicSwapMethod.INIT
transaction_payload.data = atomic_swap_init_payload.SerializeToString()
serialized_transaction_payload = transaction_payload.SerializeToString()
transaction_header = TransactionHeader(
signer_public_key=BOT_PUBLIC_KEY,
family_name=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get('family_name'),
family_version=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get('family_version'),
inputs=INPUTS,
outputs=OUTPUTS,
dependencies=[],
payload_sha512=hash512(data=serialized_transaction_payload),
batcher_public_key=RANDOM_NODE_PUBLIC_KEY,
nonce=time.time().hex().encode(),
)
serialized_header = transaction_header.SerializeToString()
transaction_request = TpProcessRequest(
header=transaction_header,
payload=serialized_transaction_payload,
signature=create_signer(private_key=BOT_PRIVATE_KEY).sign(serialized_header),
)
swap_info = AtomicSwapInfo()
swap_info.swap_id = SWAP_ID
swap_info.state = AtomicSwapInfo.OPENED
swap_info.amount = TOKENS_AMOUNT_TO_SWAP
swap_info.created_at = CURRENT_TIMESTAMP
swap_info.email_address_encrypted_optional = ALICE_EMAIL_ADDRESS_ENCRYPTED_BY_INITIATOR
swap_info.sender_address = BOT_ADDRESS
swap_info.sender_address_non_local = BOT_ETHEREUM_ADDRESS
swap_info.receiver_address = ALICE_ADDRESS
serialized_swap_info = swap_info.SerializeToString()
mock_context = StubContext(inputs=INPUTS, outputs=OUTPUTS, initial_state={
ADDRESS_TO_STORE_SWAP_INFO_BY: serialized_swap_info,
})
with pytest.raises(InvalidTransaction) as error:
AtomicSwapHandler().apply(transaction=transaction_request, context=mock_context)
assert 'Atomic swap ID has already been taken, please use a different one.' == str(error.value)
def test_atomic_swap_init():
"""
Case: initialize swap of bot's Remme node tokens to Alice's ERC20 Remme tokens.
Expect: bot sends commission to the zero account address, swap amount is decreased from bot account.
"""
atomic_swap_init_payload = AtomicSwapInitPayload(
receiver_address=ALICE_ADDRESS,
sender_address_non_local=BOT_ETHEREUM_ADDRESS,
amount=TOKENS_AMOUNT_TO_SWAP,
swap_id=SWAP_ID,
secret_lock_by_solicitor=BOT_IT_IS_INITIATOR_MARK,
email_address_encrypted_by_initiator=ALICE_EMAIL_ADDRESS_ENCRYPTED_BY_INITIATOR,
created_at=CURRENT_TIMESTAMP,
)
transaction_payload = TransactionPayload()
transaction_payload.method = AtomicSwapMethod.INIT
transaction_payload.data = atomic_swap_init_payload.SerializeToString()
serialized_transaction_payload = transaction_payload.SerializeToString()
transaction_header = TransactionHeader(
signer_public_key=BOT_PUBLIC_KEY,
family_name=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get('family_name'),
family_version=TRANSACTION_REQUEST_ACCOUNT_HANDLER_PARAMS.get('family_version'),
inputs=INPUTS,
outputs=OUTPUTS,
dependencies=[],
payload_sha512=hash512(data=serialized_transaction_payload),
batcher_public_key=RANDOM_NODE_PUBLIC_KEY,
nonce=time.time().hex().encode(),
)
serialized_header = transaction_header.SerializeToString()
transaction_request = TpProcessRequest(
header=transaction_header,
payload=serialized_transaction_payload,
signature=create_signer(private_key=BOT_PRIVATE_KEY).sign(serialized_header),
)
bot_account = Account()
bot_account.balance = 5000
serialized_bot_account = bot_account.SerializeToString()
zero_account = Account()
zero_account.balance = 0
serialized_zero_account = zero_account.SerializeToString()
swap_commission_setting = Setting()
swap_commission_setting.entries.add(key=SETTINGS_SWAP_COMMISSION, value=str(SWAP_COMMISSION_AMOUNT))
serialized_swap_commission_setting = swap_commission_setting.SerializeToString()
genesis_members_setting = Setting()
genesis_members_setting.entries.add(key=SETTINGS_KEY_ZERO_ADDRESS_OWNERS, value=f'{BOT_PUBLIC_KEY},')
serialized_genesis_members_setting = genesis_members_setting.SerializeToString()
mock_context = StubContext(inputs=INPUTS, outputs=OUTPUTS, initial_state={
BLOCK_INFO_CONFIG_ADDRESS: SERIALIZED_BLOCK_INFO_CONFIG,
BLOCK_INFO_ADDRESS: SERIALIZED_BLOCK_INFO,
BOT_ADDRESS: serialized_bot_account,
ZERO_ADDRESS: serialized_zero_account,
ADDRESS_TO_GET_SWAP_COMMISSION_AMOUNT_BY: serialized_swap_commission_setting,
ADDRESS_TO_GET_GENESIS_MEMBERS_AS_STRING_BY: serialized_genesis_members_setting,
})
swap_info = AtomicSwapInfo()
swap_info.swap_id = SWAP_ID
swap_info.state = AtomicSwapInfo.OPENED
swap_info.amount = TOKENS_AMOUNT_TO_SWAP
swap_info.created_at = CURRENT_TIMESTAMP
swap_info.email_address_encrypted_optional = ALICE_EMAIL_ADDRESS_ENCRYPTED_BY_INITIATOR
swap_info.sender_address = BOT_ADDRESS
swap_info.sender_address_non_local = BOT_ETHEREUM_ADDRESS
swap_info.receiver_address = ALICE_ADDRESS
swap_info.is_initiator = True
serialized_swap_info = swap_info.SerializeToString()
expected_bot_account = Account()
expected_bot_account.balance = 5000 - TOKENS_AMOUNT_TO_SWAP - SWAP_COMMISSION_AMOUNT
serialized_expected_bot_account = expected_bot_account.SerializeToString()
expected_zero_account = Account()
expected_zero_account.balance = SWAP_COMMISSION_AMOUNT
serialized_expected_zero_account = expected_zero_account.SerializeToString()
expected_state = {
BOT_ADDRESS: serialized_expected_bot_account,
ZERO_ADDRESS: serialized_expected_zero_account,
ADDRESS_TO_STORE_SWAP_INFO_BY: serialized_swap_info,
}
AtomicSwapHandler().apply(transaction=transaction_request, context=mock_context)
state_as_list = mock_context.get_state(addresses=[
ADDRESS_TO_STORE_SWAP_INFO_BY, BOT_ADDRESS, ZERO_ADDRESS,
])
state_as_dict = {entry.address: entry.data for entry in state_as_list}
assert expected_state == state_as_dict
