tradehub.authenticated_client.AuthenticatedClient.send_tokens() - Code Metrics - Inspection of "Add Coveralls; Separate TXN Construction" - Mai-Te-Pora/tradehub-python - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — main (#23)

by Switcheolytics

created 2021-02-22 05:11 UTC

AuthenticatedClient.send_tokens() A

↳ Parent: tradehub.authenticated_client

Complexity

Conditions

Size

Total Lines	10
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	10
dl	0
loc	10
rs	9.3333
c	0
b	0
f	0
cc	5
nop	3

from tradehub.transactions import Transactions as TradehubTransactions
import tradehub.types as types
from tradehub.utils import to_tradehub_asset_amount, format_withdraw_address
from tradehub.wallet import Wallet


class AuthenticatedClient(TradehubTransactions):

    '''
    TODO
    # AMM reward % -> /get_amm_reward_percentage
    # Vault types -> /get_vault_types
    # Vaults by address -> /get_vaults?address=${address}
    '''

    def __init__(self, wallet: Wallet, node_ip: str, node_port: int = 5001, network: str = "testnet"):
        """
        """
        TradehubTransactions.__init__(self, wallet=wallet, node_ip=node_ip, node_port=node_port, network=network)
        self.wallet = wallet

    # Authenticated Client Functions
    '''
        The way each of these functions work follow a similar pattern.
        (1) The function is passed a message that matches a class from the type file.
        (2) That message and matching transaction type are sent to a function that standardizes builds of transaction sent to the blockchain.
        (3) Inside that standardization are the:
            (3a) - Determination of fees
            (3b) - Transformation of the message class to a Python dictionary/JSON object to facilitate signing and broadcast to the network.
            (3c) - Determination of account details
        (4) With everything standardized, each of the objects are then sent off to be signed and broadcast to the Tradehub blockchain.
    '''
    def update_profile(self, message: types.UpdateProfileMessage, fee: dict = None):
        '''
            message = {
                username: 'PythonAPI',
                twitter: '',
            }
        '''
        transaction_type = "UPDATE_PROFILE_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def send_tokens(self, message: types.SendTokensMessage, fee: dict = None):
        transaction_type = "SEND_TOKENS_TYPE"
        if hasattr(message, 'from_address') and message.from_address in [None, ""]:
            message.from_address = self.wallet.address
        amounts = []
        for amount in message.amount:
            formatted_amount = to_tradehub_asset_amount(amount=float(amount.amount), decimals=self.tokens[amount.denom]["decimals"])
            amounts.append(types.SendTokensAmount(amount=formatted_amount, denom=amount.denom))
        message.amount = sorted(amounts, key=lambda x: x.denom.lower())  # When dealing with coin lists in Cosmos it is a requirement that they be ordered by name - https://github.com/cosmos/cosmos-sdk/blob/master/types/coin.go#L215
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def create_order(self, message: types.CreateOrderMessage, fee: dict = None):
        '''
            {
                market: "swth_eth",
                side: "sell",
                quantity: "200",
                price: "0.00002",
                order_type: "limit",
            }
        '''
        return self.create_orders(messages=[message], fee=fee)

    def create_orders(self, messages: [types.CreateOrderMessage], fee: dict = None):
        transaction_type = "CREATE_ORDER_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)

    def cancel_order(self, message: types.CancelOrderMessage, fee: dict = None):
        return self.cancel_orders(messages=[message], fee=fee)

    def cancel_orders(self, messages: [types.CancelOrderMessage], fee: dict = None):
        transaction_type = "CANCEL_ORDER_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)

    def cancel_all(self, message: types.CancelAllMessage, fee: dict = None):
        transaction_type = "CANCEL_ALL_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def edit_order(self, message: types.EditOrderMessage, fee: dict = None):
        return self.edit_orders(messages=[message], fee=fee)

    def edit_orders(self, messages: [types.EditOrderMessage], fee: dict = None):
        transaction_type = "EDIT_ORDER_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)

    def set_leverage(self, message: types.SetLeverageMessage, fee: dict = None):
        return self.set_leverages(messages=[message], fee=fee)

    def set_leverages(self, messages: [types.SetLeverageMessage], fee: dict = None):
        transaction_type = "SET_LEVERAGE_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)

    def edit_margin(self, message: types.EditMarginMessage, fee: dict = None):
        return self.edit_margins(messages=[message], fee=fee)

    def edit_margins(self, messages: [types.EditMarginMessage], fee: dict = None):
        transaction_type = "EDIT_MARGIN_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)

    def stake_switcheo(self, message=types.DelegateTokensMessage, fee: dict = None):
        transaction_type = "DELEGATE_TOKENS_MSG_TYPE"
        message.amount.amount = to_tradehub_asset_amount(amount=float(message.amount.amount), decimals=self.tokens["swth"]["decimals"])
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def claim_staking_rewards(self, message=types.WithdrawDelegatorRewardsMessage, fee: dict = None):
        transaction_type = "WITHDRAW_DELEGATOR_REWARDS_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def claim_all_staking_rewards(self, message=types.WithdrawAllDelegatorRewardsParams, fee: dict = None):
        transaction_type = "WITHDRAW_DELEGATOR_REWARDS_MSG_TYPE"
        messages = []
        for validator_address in message.validator_addresses:
            messages.append(types.WithdrawDelegatorRewardsMessage(delegator_address=message.delegator_address, validator_address=validator_address))
        return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)

    def unbond_tokens(self, message: types.BeginUnbondingTokensMessage, fee: dict = None):
        transaction_type = "BEGIN_UNBONDING_TOKENS_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def redelegate_tokens(self, message: types.BeginRedelegatingTokensMessage, fee: dict = None):
        transaction_type = "BEGIN_REDELEGATING_TOKENS_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def create_withdraw(self, message: types.CreateWithdrawMessage, blockchain: str, fee: dict = None):
        message.fee_address = 'swth1prv0t8j8tqcdngdmjlt59pwy6dxxmtqgycy2h7'
        message.to_address = format_withdraw_address(address=message.to_address, blockchain=blockchain)
        transaction_type = "CREATE_WITHDRAWAL_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def create_validator(self, message: types.CreateValidatorMessage, fee: dict = None):
        transaction_type = "CREATE_VALIDATOR_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def create_sub_account(self, message: types.CreateSubAccountMessage, fee: dict = None):
        transaction_type = "CREATE_SUB_ACCOUNT_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def activate_sub_account(self, message: types.ActivateSubAccountMessage, fee: dict = None):
        transaction_type = "ACTIVATE_SUB_ACCOUNT_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def add_liquidity(self, message: types.AddLiquidityMessage, fee: dict = None):
        transaction_type = "ADD_LIQUIDITY_MSG_TYPE"
        if not hasattr(message, 'min_shares'):
            message.min_shares = '0'
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def remove_liquidity(self, message: types.RemoveLiquidityMessage, fee: dict = None):
        transaction_type = "REMOVE_LIQUIDITY_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def stake_pool_token(self, message: types.StakePoolTokenMessage, fee: dict = None):
        transaction_type = "STAKE_POOL_TOKEN_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def unstake_pool_token(self, message: types.UnstakePoolTokenMessage, fee: dict = None):
        transaction_type = "UNSTAKE_POOL_TOKEN_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)

    def claim_pool_rewards(self, message: types.ClaimPoolRewardsMessage, fee: dict = None):
        transaction_type = "CLAIM_POOL_REWARDS_MSG_TYPE"
        return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)


1			from tradehub.transactions import Transactions as TradehubTransactions
2			import tradehub.types as types
3			from tradehub.utils import to_tradehub_asset_amount, format_withdraw_address
4			from tradehub.wallet import Wallet
5
6
7			class AuthenticatedClient(TradehubTransactions):
8
9			'''
10			TODO
11			# AMM reward % -> /get_amm_reward_percentage
12			# Vault types -> /get_vault_types
13			# Vaults by address -> /get_vaults?address=${address}
14			'''
15
16			def __init__(self, wallet: Wallet, node_ip: str, node_port: int = 5001, network: str = "testnet"):
17			"""
18			"""
19			TradehubTransactions.__init__(self, wallet=wallet, node_ip=node_ip, node_port=node_port, network=network)
20			self.wallet = wallet
21
22			# Authenticated Client Functions
23			'''
24			The way each of these functions work follow a similar pattern.
25			(1) The function is passed a message that matches a class from the type file.
26			(2) That message and matching transaction type are sent to a function that standardizes builds of transaction sent to the blockchain.
27			(3) Inside that standardization are the:
28			(3a) - Determination of fees
29			(3b) - Transformation of the message class to a Python dictionary/JSON object to facilitate signing and broadcast to the network.
30			(3c) - Determination of account details
31			(4) With everything standardized, each of the objects are then sent off to be signed and broadcast to the Tradehub blockchain.
32			'''
33			def update_profile(self, message: types.UpdateProfileMessage, fee: dict = None):
34			'''
35			message = {
36			username: 'PythonAPI',
37			twitter: '',
38			}
39			'''
40			transaction_type = "UPDATE_PROFILE_MSG_TYPE"
41			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
42
43			def send_tokens(self, message: types.SendTokensMessage, fee: dict = None):
44			transaction_type = "SEND_TOKENS_TYPE"
45			if hasattr(message, 'from_address') and message.from_address in [None, ""]:
46			message.from_address = self.wallet.address
47			amounts = []
48			for amount in message.amount:
49			formatted_amount = to_tradehub_asset_amount(amount=float(amount.amount), decimals=self.tokens[amount.denom]["decimals"])
50			amounts.append(types.SendTokensAmount(amount=formatted_amount, denom=amount.denom))
51			message.amount = sorted(amounts, key=lambda x: x.denom.lower()) # When dealing with coin lists in Cosmos it is a requirement that they be ordered by name - https://github.com/cosmos/cosmos-sdk/blob/master/types/coin.go#L215
52			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
53
54			def create_order(self, message: types.CreateOrderMessage, fee: dict = None):
55			'''
56			{
57			market: "swth_eth",
58			side: "sell",
59			quantity: "200",
60			price: "0.00002",
61			order_type: "limit",
62			}
63			'''
64			return self.create_orders(messages=[message], fee=fee)
65
66			def create_orders(self, messages: [types.CreateOrderMessage], fee: dict = None):
67			transaction_type = "CREATE_ORDER_MSG_TYPE"
68			return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)
69
70			def cancel_order(self, message: types.CancelOrderMessage, fee: dict = None):
71			return self.cancel_orders(messages=[message], fee=fee)
72
73			def cancel_orders(self, messages: [types.CancelOrderMessage], fee: dict = None):
74			transaction_type = "CANCEL_ORDER_MSG_TYPE"
75			return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)
76
77			def cancel_all(self, message: types.CancelAllMessage, fee: dict = None):
78			transaction_type = "CANCEL_ALL_MSG_TYPE"
79			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
80
81			def edit_order(self, message: types.EditOrderMessage, fee: dict = None):
82			return self.edit_orders(messages=[message], fee=fee)
83
84			def edit_orders(self, messages: [types.EditOrderMessage], fee: dict = None):
85			transaction_type = "EDIT_ORDER_MSG_TYPE"
86			return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)
87
88			def set_leverage(self, message: types.SetLeverageMessage, fee: dict = None):
89			return self.set_leverages(messages=[message], fee=fee)
90
91			def set_leverages(self, messages: [types.SetLeverageMessage], fee: dict = None):
92			transaction_type = "SET_LEVERAGE_MSG_TYPE"
93			return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)
94
95			def edit_margin(self, message: types.EditMarginMessage, fee: dict = None):
96			return self.edit_margins(messages=[message], fee=fee)
97
98			def edit_margins(self, messages: [types.EditMarginMessage], fee: dict = None):
99			transaction_type = "EDIT_MARGIN_MSG_TYPE"
100			return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)
101
102			def stake_switcheo(self, message=types.DelegateTokensMessage, fee: dict = None):
103			transaction_type = "DELEGATE_TOKENS_MSG_TYPE"
104			message.amount.amount = to_tradehub_asset_amount(amount=float(message.amount.amount), decimals=self.tokens["swth"]["decimals"])
105			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
106
107			def claim_staking_rewards(self, message=types.WithdrawDelegatorRewardsMessage, fee: dict = None):
108			transaction_type = "WITHDRAW_DELEGATOR_REWARDS_MSG_TYPE"
109			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
110
111			def claim_all_staking_rewards(self, message=types.WithdrawAllDelegatorRewardsParams, fee: dict = None):
112			transaction_type = "WITHDRAW_DELEGATOR_REWARDS_MSG_TYPE"
113			messages = []
114			for validator_address in message.validator_addresses:
115			messages.append(types.WithdrawDelegatorRewardsMessage(delegator_address=message.delegator_address, validator_address=validator_address))
116			return self.submit_transaction_on_chain(messages=messages, transaction_type=transaction_type, fee=fee)
117
118			def unbond_tokens(self, message: types.BeginUnbondingTokensMessage, fee: dict = None):
119			transaction_type = "BEGIN_UNBONDING_TOKENS_MSG_TYPE"
120			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
121
122			def redelegate_tokens(self, message: types.BeginRedelegatingTokensMessage, fee: dict = None):
123			transaction_type = "BEGIN_REDELEGATING_TOKENS_MSG_TYPE"
124			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
125
126			def create_withdraw(self, message: types.CreateWithdrawMessage, blockchain: str, fee: dict = None):
127			message.fee_address = 'swth1prv0t8j8tqcdngdmjlt59pwy6dxxmtqgycy2h7'
128			message.to_address = format_withdraw_address(address=message.to_address, blockchain=blockchain)
129			transaction_type = "CREATE_WITHDRAWAL_TYPE"
130			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
131
132			def create_validator(self, message: types.CreateValidatorMessage, fee: dict = None):
133			transaction_type = "CREATE_VALIDATOR_MSG_TYPE"
134			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
135
136			def create_sub_account(self, message: types.CreateSubAccountMessage, fee: dict = None):
137			transaction_type = "CREATE_SUB_ACCOUNT_MSG_TYPE"
138			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
139
140			def activate_sub_account(self, message: types.ActivateSubAccountMessage, fee: dict = None):
141			transaction_type = "ACTIVATE_SUB_ACCOUNT_MSG_TYPE"
142			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
143
144			def add_liquidity(self, message: types.AddLiquidityMessage, fee: dict = None):
145			transaction_type = "ADD_LIQUIDITY_MSG_TYPE"
146			if not hasattr(message, 'min_shares'):
147			message.min_shares = '0'
148			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
149
150			def remove_liquidity(self, message: types.RemoveLiquidityMessage, fee: dict = None):
151			transaction_type = "REMOVE_LIQUIDITY_MSG_TYPE"
152			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
153
154			def stake_pool_token(self, message: types.StakePoolTokenMessage, fee: dict = None):
155			transaction_type = "STAKE_POOL_TOKEN_MSG_TYPE"
156			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
157
158			def unstake_pool_token(self, message: types.UnstakePoolTokenMessage, fee: dict = None):
159			transaction_type = "UNSTAKE_POOL_TOKEN_MSG_TYPE"
160			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
161
162			def claim_pool_rewards(self, message: types.ClaimPoolRewardsMessage, fee: dict = None):
163			transaction_type = "CLAIM_POOL_REWARDS_MSG_TYPE"
164			return self.submit_transaction_on_chain(messages=[message], transaction_type=transaction_type, fee=fee)
165

Mai-Te-Pora / tradehub-python

Pull Request — main (#23)

AuthenticatedClient.send_tokens() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like