示例#1
0
    def _get_token_balances(user: User):

        def get_token_info(transfer_account: TransferAccount):
            token = transfer_account.token
            limit, limit_amount = TokenProcessor.get_default_limit(user, token)
            exchange_rate = TokenProcessor.get_exchange_rate(user, token)
            return {
                "name": token.symbol,
                "balance": transfer_account.balance,
                "exchange_rate": exchange_rate,
                "limit": limit,
                "token": token
            }

        def check_if_ge_limit(token_info):
            return 'GE Liquid Token' in token_info['limit'].name

        def token_string(limit_type: Type[AggregateLimit], t: dict):
            if isinstance(t['limit'], limit_type):

                with ephemeral_alchemy_object(
                        CreditTransfer,
                        transfer_type=TransferTypeEnum.PAYMENT,
                        transfer_subtype=TransferSubTypeEnum.AGENT_OUT,
                        sender_user=user,
                        recipient_user=user,
                        token=t['token'],
                        amount=0
                ) as dummy_transfer:

                    allowed_amount = f"{rounded_dollars(str(t['limit'].available_base(dummy_transfer)))}"
                    rounded_rate = round_to_sig_figs(t['exchange_rate'], 3)
                    return (
                        f"{allowed_amount} {t['name']} (1 {t['name']} = {rounded_rate} {reserve_token.symbol})"
                    )
            else:
                return ""

            # transfer accounts could be created for other currencies exchanged with, but we don't want to list those

        transfer_accounts = filter(lambda x: x.is_ghost is not True, user.transfer_accounts)
        token_info_list = list(map(get_token_info, transfer_accounts))

        token_balances_dollars = "\n".join(map(lambda x: f"{x['name']} {rounded_dollars(x['balance'])}",
                                               token_info_list))

        reserve_token = user.get_reserve_token()
        ge_tokens = list(filter(check_if_ge_limit, token_info_list))
        is_ge = len(ge_tokens) > 0
        if is_ge:
            exchange_list = list(map(lambda i: token_string(BalanceFractionLimit, i), ge_tokens))
        else:
            exchange_list = list(map(lambda i: token_string(TotalAmountLimit, i), token_info_list))

        if len(exchange_list) == 0:
            token_exchanges = None
        else:
            token_exchanges = "\n".join(exchange_list)

        return token_balances_dollars, token_exchanges
示例#2
0
 def get_exchange_rate(user: User, from_token: Token):
     to_token = user.get_reserve_token()
     if from_token == to_token:
         return None
     exchange = Exchange()
     return exchange.get_exchange_rate(from_token, to_token)
示例#3
0
    def _get_token_balances(user: User):
        def get_token_info(transfer_account: TransferAccount):
            token = transfer_account.token
            limit = TokenProcessor.get_default_limit(user, token,
                                                     transfer_account)
            exchange_rate = TokenProcessor.get_exchange_rate(user, token)
            return {
                "name": token.symbol,
                "balance": transfer_account.balance,
                "exchange_rate": exchange_rate,
                "limit": limit,
            }

        def check_if_ge_limit(token_info):
            return 'GE Liquid Token' in token_info['limit'].name
            # return (token_info['exchange_rate'] is not None
            #         and token_info['limit'] is not None
            #         and token_info['limit'].transfer_balance_fraction is not None)

        def ge_string(t):
            if t['limit'].transfer_balance_fraction:
                # TODO: This doesn't seem DRY with respect to 'get default exchange rate'
                allowed_amount = rounded_dollars(
                    t['limit'].transfer_balance_fraction * t['balance'])
                rounded_rate = round_to_sig_figs(t['exchange_rate'], 3)
                return (
                    f"{allowed_amount} {t['name']} (1 {t['name']} = {rounded_rate} {reserve_token.symbol})"
                )
            else:
                return ""

        def standard_string(t):
            if t['limit'].total_amount:
                allowed_amount = f"{rounded_dollars(str(t['limit'].total_amount))}"
                rounded_rate = round_to_sig_figs(t['exchange_rate'], 3)
                return (
                    f"{allowed_amount} {t['name']} (1 {t['name']} = {rounded_rate} {reserve_token.symbol})"
                )
            else:
                return ""

            # transfer accounts could be created for other currencies exchanged with, but we don't want to list those

        transfer_accounts = filter(lambda x: x.is_ghost is not True,
                                   user.transfer_accounts)
        token_info_list = list(map(get_token_info, transfer_accounts))

        token_balances_dollars = "\n".join(
            map(lambda x: f"{x['name']} {rounded_dollars(x['balance'])}",
                token_info_list))

        reserve_token = user.get_reserve_token()
        ge_tokens = list(filter(check_if_ge_limit, token_info_list))
        is_ge = len(ge_tokens) > 0
        if is_ge:
            exchange_list = list(map(ge_string, ge_tokens))
        else:
            exchange_list = list(map(standard_string, token_info_list))

        if len(exchange_list) == 0:
            token_exchanges = None
        else:
            token_exchanges = "\n".join(exchange_list)

        return token_balances_dollars, token_exchanges