def _handle_swap(self, swap_data: str, src_token: str, dst_token: str, retry=False):
swap_json = swap_query_res(swap_data)
# this is an id, and not the TX hash since we don't actually know where the TX happened, only the id of the
# swap reported by the contract
swap_id = get_swap_id(swap_json)
dest_address = swap_json['destination']
self.logger.debug(f'{swap_json}')
amount = int(swap_json['amount'])
swap_failed = False
fee = 0
data = b''
nonce = int(swap_json['nonce'])
swap = None
try:
if dst_token == 'native':
data, tx_dest, tx_amount, tx_token, fee = self._tx_native_params(amount, dest_address, retry)
else:
self.erc20.address = dst_token
data, tx_dest, tx_amount, tx_token, fee = self._tx_erc20_params(amount, dest_address, dst_token, retry)
if retry:
original_nonce = nonce
nonce = int(self.multisig_wallet.get_token_nonce(swap_retry_address) + 1) # + 1 to advance the counter
swap = Swap.objects.get(src_tx_hash=swap_id)
swap.status = Status.SWAP_FAILED
self.update_retry_db(f"{original_nonce}|{tx_token}", f"{nonce}|{swap_retry_address.lower()}")
tx_token = w3.toChecksumAddress(swap_retry_address)
msg = message.Submit(w3.toChecksumAddress(tx_dest),
tx_amount, # if we are swapping token, no ether should be rewarded
nonce,
tx_token,
fee,
data)
except ValueError as e:
self.logger.error(f"Error: {e}")
swap_failed = True
# this could have already been set by retry
if not swap:
swap = Swap(src_network="Secret", src_tx_hash=swap_id, unsigned_tx=data, src_coin=src_token,
dst_coin=dst_token, dst_address=dest_address, amount=str(amount), dst_network="Ethereum",
status=Status.SWAP_FAILED)
if swap_failed or not self._validate_fee(amount, fee):
self._save_failed_swap(swap, swap_id)
else:
self._broadcast_and_save(msg, swap, swap_id)
def _handle(self, event: AttributeDict):
"""Extracts tx data from @event and add unsigned_tx to db"""
if not self.contract.verify_destination(event):
return
amount = str(self.contract.extract_amount(event))
try:
block_number, tx_hash, recipient, token = self.contract.parse_swap_event(
event)
if token is None:
token = 'native'
except ValueError:
return
try:
s20 = self._get_s20(token)
mint = mint_json(amount, tx_hash, recipient, s20.address)
unsigned_tx = create_unsigned_tx(self.config.scrt_swap_address,
mint, self.config.chain_id,
self.config.enclave_key,
self.config.swap_code_hash,
self.multisig.address)
tx = Swap(src_tx_hash=tx_hash,
status=Status.SWAP_UNSIGNED,
unsigned_tx=unsigned_tx,
src_coin=token,
dst_coin=s20.name,
dst_address=s20.address,
src_network="Ethereum",
sequence=self.sequence,
amount=amount)
tx.save(force_insert=True)
self.sequence = self.sequence + 1
self.logger.info(
f"saved new Ethereum -> Secret transaction {tx_hash}, for {amount} {s20.name}"
)
# SwapTrackerObject.update_last_processed(src=Source.ETH.value, update_val=block_number)
except (IndexError, AttributeError, KeyError) as e:
self.logger.error(f"Failed on tx {tx_hash}, block {block_number}, "
f"due to error: {e}")
except RuntimeError as e:
self.logger.error(
f"Failed to create swap tx for eth hash {tx_hash}, block {block_number}. Error: {e}"
)
except NotUniqueError as e:
self.logger.error(
f"Tried to save duplicate TX, might be a catch up issue - {e}")
# return block_number, tx_hash, recipient, s20
SwapTrackerObject.update_last_processed('Ethereum', block_number)
def _handle_swap(self, swap_data: str, src_token: str, dst_token: str):
swap_json = swap_query_res(swap_data)
# this is an id, and not the TX hash since we don't actually know where the TX happened, only the id of the
# swap reported by the contract
swap_id = get_swap_id(swap_json)
dest_address = swap_json['destination']
self.logger.info(f'{swap_json}')
amount = int(swap_json['amount'])
if dst_token == 'native':
data, tx_dest, tx_amount, tx_token, fee = self._tx_native_params(
amount, dest_address)
else:
self.erc20.address = dst_token
data, tx_dest, tx_amount, tx_token, fee = self._tx_erc20_params(
amount, dest_address, dst_token)
if not self._validate_fee(amount, fee):
self.logger.error("Tried to swap an amount too low to cover fee")
swap = Swap(src_network="Secret",
src_tx_hash=swap_id,
unsigned_tx=data,
src_coin=src_token,
dst_coin=dst_token,
dst_address=dest_address,
amount=str(amount),
dst_network="Ethereum",
status=Status.SWAP_FAILED)
try:
swap.save()
except (DuplicateKeyError, NotUniqueError):
pass
return
msg = message.Submit(
tx_dest,
tx_amount, # if we are swapping token, no ether should be rewarded
int(swap_json['nonce']),
tx_token,
fee,
data)
# todo: check we have enough ETH
swap = Swap(src_network="Secret",
src_tx_hash=swap_id,
unsigned_tx=data,
src_coin=src_token,
dst_coin=dst_token,
dst_address=dest_address,
amount=str(amount),
dst_network="Ethereum",
status=Status.SWAP_FAILED)
try:
tx_hash = self._broadcast_transaction(msg)
swap.dst_tx_hash = tx_hash
swap.status = Status.SWAP_SUBMITTED
except (ValueError, TransactionNotFound) as e:
self.logger.critical(
f"Failed to broadcast transaction for msg {repr(msg)}: {e}")
finally:
try:
swap.save()
except (DuplicateKeyError, NotUniqueError):
pass