Análise Quantitativa do Mercado de Moeda Digital

Análise Quantitativa do Mercado de Moeda Digital

Uma abordagem baseada em dados para a análise especulativa das moedas digitais

E quanto ao preço do Bitcoin? Quais são as razões para o aumento e diminuição do preço da moeda digital? Os preços de mercado de diferentes Altcoins estão inextricavelmente ligados ou em grande parte independentes? Como podemos prever o que acontecerá em seguida?

Os artigos sobre moeda digital, como Bitcoin e Ethereum, estão agora cheios de especulações. Centenas de auto-proclamados especialistas estão defendendo a tendência que esperam. O que falta a muitas dessas análises é uma base sólida para dados básicos e modelos estatísticos.

O objetivo deste artigo é fornecer uma breve introdução à análise de moedas digitais usando Python. Usaremos um script Python simples para recuperar, analisar e visualizar os dados de diferentes moedas digitais. Neste processo, encontraremos tendências interessantes no comportamento do mercado dessas flutuações e como elas se desenvolvem.

Este não é um artigo explicando moeda digital, nem é uma opinião sobre quais moedas específicas aumentarão e quais diminuirão. Pelo contrário, o que nos concentramos neste tutorial é obter os dados originais e encontrar a história escondida nos números.

Passo 1: Configurar o nosso ambiente de trabalho com dados

Este tutorial é destinado a entusiastas, engenheiros e cientistas de dados em todos os níveis de habilidade. Se você é um líder da indústria ou um novato em programação, a única habilidade que você precisa é uma compreensão básica da linguagem de programação Python e conhecimento suficiente de operações de linha de comando (ser capaz de configurar um projeto de ciência de dados é suficiente).

1.1 Instale o docker FMZ Quant e configure o Anaconda

• Docker System da plataforma FMZ Quant A plataforma FMZ QuantFMZ.COMEste conjunto de interfaces inclui ferramentas práticas, como consulta de informações de conta, consulta de alto, aberto, baixo, preço de recebimento, volume de negociação e vários indicadores de análise técnica comumente usados de várias trocas principais. Em particular, fornece forte suporte técnico para as interfaces públicas de API que conectam as principais trocas principais no processo de negociação real.

Todos os recursos acima mencionados estão encapsulados em um sistema Docker-like. O que precisamos fazer é comprar ou alugar nossos próprios serviços de computação em nuvem e implantar o sistema Docker.

No nome oficial da plataforma FMZ Quant, este sistema Docker é chamado de sistema Docker.

Por favor, consulte meu artigo anterior sobre como implantar um docker e robô:https://www.fmz.com/bbs-topic/9864.

Os leitores que desejam comprar seu próprio servidor de computação em nuvem para implantar dockers podem consultar este artigo:https://www.fmz.com/digest-topic/5711.

Depois de implantar o servidor de computação em nuvem e o sistema docker com sucesso, em seguida, vamos instalar o maior artefato atual do Python: Anaconda

Para realizar todos os ambientes de programa relevantes (bibliotecas de dependências, gerenciamento de versões, etc.) necessários neste artigo, a maneira mais simples é usar o Anaconda.

Uma vez que instalamos o Anaconda no serviço de nuvem, recomendamos que o servidor de nuvem instale o sistema Linux mais a versão da linha de comando do Anaconda.

Para o método de instalação do Anaconda, consulte o guia oficial do Anaconda:https://www.anaconda.com/distribution/.

Se você é um programador Python experiente e se sente que não precisa usar o Anaconda, não é problema nenhum. Assumo que você não precisa de ajuda ao instalar o ambiente dependente necessário. Você pode ignorar esta seção diretamente.

1.2 Criar um ambiente de projeto de análise de dados para o Anaconda

Uma vez instalado o Anaconda, precisamos criar um novo ambiente para gerenciar nossos pacotes dependentes.

conda create --name cryptocurrency-analysis python=3

para criar um novo ambiente Anaconda para o nosso projeto.

Em seguida, entrada:

source activate cryptocurrency-analysis (linux/MacOS operating system)
or
activate cryptocurrency-analysis (windows operating system)

para activar o ambiente.

Em seguida, entrada:

conda install numpy pandas nb_conda jupyter plotly

para instalar vários pacotes dependentes necessários para este projeto.

Nota: Por que usar o ambiente Anaconda? Se você planeja executar muitos projetos Python em seu computador, é útil separar os pacotes dependentes (bibliotecas de software e pacotes) de diferentes projetos para evitar conflitos.

1.3 Crie um bloco de notas Jupyter

Após a instalação do ambiente e dos pacotes dependentes, executar:

jupyter notebook

para iniciar o kernel do iPython, visitehttp://localhost:8888/com o seu navegador, crie um novo bloco de notas Python, certificando-se de que ele usa o:

Python [conda env:cryptocurrency-analysis]

núcleo

1.4 Embalagens dependentes da importação

Crie um bloco de notas Jupyter vazio, e a primeira coisa que precisamos fazer é importar os pacotes dependentes necessários.

import os
import numpy as np
import pandas as pd
import pickle
from datetime import datetime

Também precisamos importar Plotly e habilitar o modo offline:

import plotly.offline as py
import plotly.graph_objs as go
import plotly.figure_factory as ff
py.init_notebook_mode(connected=True)

Passo 2: Obtenha informações sobre o preço da moeda digital

A preparação está completa e agora podemos começar a obter os dados a serem analisados. Primeiro, usaremos a interface API da plataforma FMZ Quant para obter os dados de preço do Bitcoin.

Para a utilização destas duas funções, consulte:https://www.fmz.com/api.

2.1 Escrever uma função de recolha de dados Quandl

Para facilitar a aquisição de dados, precisamos escrever uma função para baixar e sincronizar dados do Quandl (quandl.comEsta é uma interface gratuita de dados financeiros, que goza de uma alta reputação no exterior. A plataforma FMZ Quant também fornece uma interface de dados semelhante, que é usada principalmente para transações reais de bots. Como o artigo se concentra principalmente na análise de dados, ainda usamos dados Quandl aqui.

Durante a transação real do bot, você pode chamar as funções GetTicker e GetRecords no Python diretamente para obter dados de preço.https://www.fmz.com/api.

def get_quandl_data(quandl_id):
    # Download and cache data columns from Quandl
    cache_path = '{}.pkl'.format(quandl_id).replace('/','-')
    try:
        f = open(cache_path, 'rb')
        df = pickle.load(f)   
        print('Loaded {} from cache'.format(quandl_id))
    except (OSError, IOError) as e:
        print('Downloading {} from Quandl'.format(quandl_id))
        df = quandl.get(quandl_id, returns="pandas")
        df.to_pickle(cache_path)
        print('Cached {} at {}'.format(quandl_id, cache_path))
    return df

Aqui, a biblioteca de picles é usada para serializar os dados e salvar os dados baixados como um arquivo, para que o programa não baixe os mesmos dados toda vez que for executado. Esta função retornará dados no formato Pandas Dataframe.

2.2 Acesso aos dados de preços de moeda digital da bolsa Kraken

Vamos tomar a Kraken Bitcoin Exchange como exemplo, começando por obter seu preço Bitcoin.

# Get prices on the Kraken Bitcoin exchange
btc_usd_price_kraken = get_quandl_data('BCHARTS/KRAKENUSD')

Usar o método head( para visualizar as primeiras cinco linhas da caixa de dados.

btc_usd_price_kraken.head()

O resultado é:

Em seguida, vamos fazer uma tabela simples para verificar a correção dos dados por visualização.

# Make a table of BTC prices
btc_trace = go.Scatter(x=btc_usd_price_kraken.index, y=btc_usd_price_kraken['Weighted Price'])
py.iplot([btc_trace])

Aqui, usamos o Plotly para completar a parte de visualização. Em comparação com o uso de algumas bibliotecas de visualização de dados Python mais maduras, como o Matplotlib, o Plotly é uma escolha menos comum, mas é realmente uma boa escolha, porque pode chamar gráficos totalmente interativos D3.js. Esses gráficos têm belos ajustes padrão, que são fáceis de explorar e muito fáceis de incorporar na página da web.

Dicas: O gráfico gerado pode ser comparado com o gráfico de preços do Bitcoin das principais bolsas (como o gráfico da OKX, Binance ou Huobi) como uma verificação rápida de integridade para confirmar se os dados baixados são geralmente consistentes.

2.3 Obter dados de preços das principais bolsas de Bitcoin

Os leitores atentos podem ter notado que há dados faltantes nos dados acima, especialmente no final de 2014 e início de 2016.

A característica da troca de moeda digital é que a relação de oferta e demanda determina o preço da moeda. Portanto, nenhum preço de transação pode se tornar o preço principal do mercado. A fim de resolver o problema e o problema de perda de dados mencionado (possivelmente devido a interrupções técnicas de energia e erros de dados), vamos baixar dados de três principais exchanges de Bitcoin no mundo e, em seguida, calcular o preço médio do Bitcoin.

Vamos começar por baixar os dados de cada troca para o quadro de dados composto por tipos de dicionário.

# Download price data from COINBASE, BITSTAMP and ITBIT
exchanges = ['COINBASE','BITSTAMP','ITBIT']

exchange_data = {}

exchange_data['KRAKEN'] = btc_usd_price_kraken

for exchange in exchanges:
    exchange_code = 'BCHARTS/{}USD'.format(exchange)
    btc_exchange_df = get_quandl_data(exchange_code)
    exchange_data[exchange] = btc_exchange_df

2.4 Integrar todos os dados num único quadro de dados

Em seguida, vamos definir uma função especial para mesclar as colunas que são comuns a cada quadro de dados em um novo quadro de dados.

def merge_dfs_on_column(dataframes, labels, col):
    '''Merge a single column of each dataframe into a new combined dataframe'''
    series_dict = {}
    for index in range(len(dataframes)):
        series_dict[labels[index]] = dataframes[index][col]
        
    return pd.DataFrame(series_dict)

Agora, todos os quadros de dados são integrados com base na coluna preço ponderado de cada conjunto de dados.

# Integrate all data frames
btc_usd_datasets = merge_dfs_on_column(list(exchange_data.values()), list(exchange_data.keys()), 'Weighted Price')

Finalmente, usamos o método tail () para visualizar as últimas cinco linhas dos dados combinados para garantir que os dados sejam corretos e completos.

btc_usd_datasets.tail()

Os resultados são apresentados como:

A partir da tabela acima, podemos ver que estes dados estão em linha com as nossas expectativas, com aproximadamente o mesmo intervalo de dados, mas ligeiramente diferente com base no atraso ou características de cada troca.

2.5 Processo de visualização dos dados de preços

Do ponto de vista da lógica de análise, o próximo passo é comparar esses dados através da visualização. Para fazer isso, precisamos definir uma função auxiliar primeiro. Ao fornecer um comando de linha única para usar dados para fazer um gráfico, chamamos de função df_scatter.

def df_scatter(df, title, seperate_y_axis=False, y_axis_label='', scale='linear', initial_hide=False):
    '''Generate a scatter plot of the entire dataframe'''
    label_arr = list(df)
    series_arr = list(map(lambda col: df[col], label_arr))
    
    layout = go.Layout(
        title=title,
        legend=dict(orientation="h"),
        xaxis=dict(type='date'),
        yaxis=dict(
            title=y_axis_label,
            showticklabels= not seperate_y_axis,
            type=scale
        )
    )
    
    y_axis_config = dict(
        overlaying='y',
        showticklabels=False,
        type=scale )
    
    visibility = 'visible'
    if initial_hide:
        visibility = 'legendonly'
        
    # Table tracking for each series
    trace_arr = []
    for index, series in enumerate(series_arr):
        trace = go.Scatter(
            x=series.index, 
            y=series, 
            name=label_arr[index],
            visible=visibility
        )
        
        # Add a separate axis to the series
        if seperate_y_axis:
            trace['yaxis'] = 'y{}'.format(index + 1)
            layout['yaxis{}'.format(index + 1)] = y_axis_config    
        trace_arr.append(trace)

    fig = go.Figure(data=trace_arr, layout=layout)
    py.iplot(fig)

Para sua fácil compreensão, este artigo não discutirá o princípio lógico desta função auxiliar demais.

Agora, podemos criar gráficos de dados de preços do Bitcoin facilmente!

# Plot all BTC transaction prices
df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange')

2.6 Dados de preços claros e agregados

Como pode ser visto no gráfico acima, embora as quatro séries de dados sigam aproximadamente o mesmo caminho, ainda há algumas alterações irregulares.

No período de 2012-2017, sabemos que o preço do Bitcoin nunca foi igual a zero, por isso removemos todos os valores zero no quadro de dados primeiro.

# Clear the "0" value
btc_usd_datasets.replace(0, np.nan, inplace=True)

Depois de reconstruir os quadros de dados, podemos ver um gráfico mais claro sem mais dados em falta.

# Plot the revised data frame
df_scatter(btc_usd_datasets, 'Bitcoin Price (USD) By Exchange')

Podemos calcular uma nova coluna agora: o preço médio diário do Bitcoin de todas as bolsas.

# Calculate the average BTC price as a new column
btc_usd_datasets['avg_btc_price_usd'] = btc_usd_datasets.mean(axis=1)

A nova coluna é o índice de preço do Bitcoin! Vamos desenhá-lo novamente para verificar se os dados parecem errados.

# Plot the average BTC price
btc_trace = go.Scatter(x=btc_usd_datasets.index, y=btc_usd_datasets['avg_btc_price_usd'])
py.iplot([btc_trace])

Mais tarde, continuaremos a usar esses dados agregados de séries de preços para determinar a taxa de câmbio entre outras moedas digitais e o USD.

Passo 3: Colete o preço das Altcoins

Até agora, temos os dados de séries temporais do preço do Bitcoin. Em seguida, vamos dar uma olhada em alguns dados de moedas digitais não-Bitcoin, ou seja, Altcoins. É claro, o termo Altcoins pode ser um pouco hiperbólico, mas no que diz respeito ao desenvolvimento atual das moedas digitais, exceto para as dez principais em valor de mercado (como Bitcoin, Ethereum, EOS, USDT, etc.), a maioria delas pode ser chamada de Altcoins. Devemos tentar ficar longe dessas moedas ao negociar, porque são muito confusas e enganosas.

3.1 Definir funções auxiliares através da API da Bolsa Poloniex

Primeiro, usamos a API da Bolsa Poloniex para obter as informações de dados das transações de moeda digital. Definimos duas funções auxiliares para obter os dados relacionados aos Altcoins. Essas duas funções baixam e armazenam dados JSON principalmente através de APIs.

Primeiro, definimos a função get_json_data, que irá baixar e armazenar dados JSON a partir do URL dado.

def get_json_data(json_url, cache_path):
    '''Download and cache JSON data, return as a dataframe.'''
    try:        
        f = open(cache_path, 'rb')
        df = pickle.load(f)   
        print('Loaded {} from cache'.format(json_url))
    except (OSError, IOError) as e:
        print('Downloading {}'.format(json_url))
        df = pd.read_json(json_url)
        df.to_pickle(cache_path)
        print('Cached {} at {}'.format(json_url, cache_path))
    return df

Em seguida, definimos uma nova função que irá gerar a solicitação HTTP da API Poloniex e chamar a função get_ json_data apenas definido para salvar os resultados de dados da chamada.

base_polo_url = 'https://poloniex.com/public?command=returnChartData&currencyPair={}&start={}&end={}&period={}'
start_date = datetime.strptime('2015-01-01', '%Y-%m-%d') # Data acquisition since 2015
end_date = datetime.now() # Until today
pediod = 86400 # pull daily data (86,400 seconds per day)

def get_crypto_data(poloniex_pair):
    '''Retrieve cryptocurrency data from poloniex'''
    json_url = base_polo_url.format(poloniex_pair, start_date.timestamp(), end_date.timestamp(), pediod)
    data_df = get_json_data(json_url, poloniex_pair)
    data_df = data_df.set_index('date')
    return data_df

A função acima extrairá o código de caracteres correspondente da moeda digital (como BTC_ETH) e retornará o quadro de dados contendo os preços históricos de duas moedas.

3.2 Baixar dados de preços de transacção da Poloniex

A grande maioria dos Altcoins não pode ser comprada em USD diretamente. Para obter essas moedas digitais, os indivíduos geralmente precisam comprar Bitcoin primeiro e, em seguida, convertê-los em Altcoins de acordo com sua relação de preço. Portanto, temos que baixar a taxa de câmbio de cada moeda digital para Bitcoin e, em seguida, usar os dados de preço de Bitcoin existentes para convertê-lo em USD. Nós baixaremos os dados de taxa de câmbio para as 9 principais moedas digitais: Ethereum, Litecoin, Ripple, EthereumClassic, Stellar, Dash, Siacoin, Monero e NEM.

altcoins = ['ETH','LTC','XRP','ETC','STR','DASH','SC','XMR','XEM']

altcoin_data = {}
for altcoin in altcoins:
    coinpair = 'BTC_{}'.format(altcoin)
    crypto_price_df = get_crypto_data(coinpair)
    altcoin_data[altcoin] = crypto_price_df

Agora, temos um dicionário contendo 9 quadros de dados, cada um dos quais contém dados históricos de preço médio diário entre Altcoins e Bitcoin.

Podemos determinar se os dados são corretos através das últimas linhas da tabela de preços Ethereum.

altcoin_data['ETH'].tail()

3.3 Unificar a unidade monetária de todos os dados de preços em USD

Agora, podemos combinar dados de taxa de câmbio BTC e Altcoins com o nosso índice de preço Bitcoin para calcular o preço histórico de cada Altcoin (em USD) diretamente.

# Calculate USD Price as a new column in each altcoin data frame
for altcoin in altcoin_data.keys():
    altcoin_data[altcoin]['price_usd'] =  altcoin_data[altcoin]['weightedAverage'] * btc_usd_datasets['avg_btc_price_usd']

Aqui, adicionamos uma nova coluna para cada quadro de dados Altcoin para armazenar seu preço USD correspondente.

Em seguida, podemos reutilizar a função merge_dfs_on_column definida anteriormente para criar um quadro de dados combinado e integrar o preço em USD de cada moeda digital.

# Combine the USD price of each Altcoin into a single data frame
combined_df = merge_dfs_on_column(list(altcoin_data.values()), list(altcoin_data.keys()), 'price_usd')

Está feito!

Agora vamos adicionar o preço do Bitcoin como a última coluna para o quadro de dados combinado.

# Add BTC price to data frame
combined_df['BTC'] = btc_usd_datasets['avg_btc_price_usd']

Agora temos um quadro de dados único, que contém os preços diários em dólares de dez moedas digitais que estamos verificando.

Chamamos a função anterior df_scatter novamente, mostrando os preços correspondentes de todas as Altcoins na forma de um gráfico.

Parece que não há problema no gráfico. Este gráfico nos mostra uma imagem completa da mudança do preço de troca para cada moeda digital nos últimos anos.

Nota: aqui usamos o eixo y da especificação logarítmica para comparar todas as moedas digitais no mesmo gráfico.

3.4 Iniciar a análise de correlação

Os leitores atentos podem ter notado que os preços das moedas digitais parecem ser relevantes, embora seus valores de moeda variem muito e sejam altamente voláteis.

Naturalmente, as conclusões baseadas em dados são mais convincentes do que intuições baseadas em imagens.

Podemos usar a função Pandas corr() para verificar a hipótese de correlação acima. Este método de teste calcula o coeficiente de correlação de Pearson de cada coluna do quadro de dados correspondente à outra coluna.

Nota de revisão de 22.8.2017: Esta secção foi alterada para utilizar a taxa de retorno diária em vez do valor absoluto do preço no cálculo do coeficiente de correlação.

O cálculo direto baseado em uma série temporal não sólida (como dados de preços brutos) pode levar ao desvio do coeficiente de correlação. Para resolver este problema, nossa solução é usar o método pct_change() para converter o valor absoluto de cada preço no quadro de dados na taxa de retorno diária correspondente.

Por exemplo, vamos calcular o coeficiente de correlação em 2016.

# Calculating the Pearson correlation coefficient for digital currencies in 2016
combined_df_2016 = combined_df[combined_df.index.year == 2016]
combined_df_2016.pct_change().corr(method='pearson')

O gráfico acima mostra o coeficiente de correlação. Quando o coeficiente está próximo de 1 ou -1, significa que esta série está correlacionada positivamente ou negativamente, respectivamente. Quando o coeficiente de correlação está perto de 0, significa que os objetos correspondentes não estão correlacionados e suas flutuações são independentes umas das outras.

Para melhor visualizar os resultados, criamos uma nova função de ajuda visual.

def correlation_heatmap(df, title, absolute_bounds=True):
    '''Plot a correlation heatmap for the entire dataframe'''
    heatmap = go.Heatmap(
        z=df.corr(method='pearson').as_matrix(),
        x=df.columns,
        y=df.columns,
        colorbar=dict(title='Pearson Coefficient'),
    )
    
    layout = go.Layout(title=title)
    
    if absolute_bounds:
        heatmap['zmax'] = 1.0
        heatmap['zmin'] = -1.0
        
    fig = go.Figure(data=[heatmap], layout=layout)
    py.iplot(fig)

correlation_heatmap(combined_df_2016.pct_change(), "Cryptocurrency Correlations in 2016")

Aqui, o valor vermelho escuro representa forte correlação (cada moeda é obviamente altamente correlacionada consigo mesma), e o valor azul escuro representa correlação inversa.

O que nos diz este gráfico? Basicamente, mostra a flutuação dos preços das diferentes moedas digitais em 2016, com pouca correlação estatisticamente significativa.

Agora, para verificar a nossa hipótese de que a correlação da moeda digital aumentou nos últimos meses, vamos usar os dados de 2017 para repetir o mesmo teste.

combined_df_2017 = combined_df[combined_df.index.year == 2017]
combined_df_2017.pct_change().corr(method='pearson')

Os dados acima são mais relevantes? São suficientes para serem utilizados como um critério de julgamento para o investimento?

No entanto, vale a pena notar que quase todas as moedas digitais se tornaram cada vez mais interconectadas.

correlation_heatmap(combined_df_2017.pct_change(), "Cryptocurrency Correlations in 2017")

Como podemos ver no gráfico acima, as coisas estão ficando cada vez mais interessantes.

Porque é que isto acontece?

Boa pergunta, mas a verdade é que não tenho a certeza...

Minha primeira reação é que os fundos de hedge recentemente começaram a negociar publicamente no mercado de moeda digital. Estes fundos detêm muito mais capital do que os traders comuns. Quando um fundo hedge seu capital investido entre várias moedas digitais, ele usa estratégias de negociação semelhantes para cada moeda de acordo com variáveis independentes (como o mercado de ações).

Uma compreensão mais profunda do XRP e do STR

Por exemplo, é óbvio do gráfico acima que o XRP (token do Ripple) tem a menor correlação com outras moedas digitais. No entanto, uma exceção notável é o STR (token do Stellar, oficialmente conhecido como Lumens), que tem uma forte correlação com o XRP (coeficiente de correlação: 0,62).

Curiosamente, Stellar e Ripple são plataformas de tecnologia financeira muito semelhantes, ambas com o objetivo de reduzir as etapas tediosas de transferência transfronteiriça entre bancos. É concebível que alguns grandes players e fundos de hedge possam usar estratégias de negociação semelhantes para seus investimentos em Stellar e Ripple, considerando a semelhança dos tokens usados pelos serviços blockchain.

Bem, é a tua vez!

As explicações acima são em grande parte especulativas, e você pode fazer melhor. Com base na base que estabelecemos, você tem centenas de maneiras diferentes de continuar a explorar as histórias contidas nos dados.

Os leitores podem consultar as pesquisas nas seguintes direcções:

• Adicione mais dados sobre moedas digitais a toda a análise.
• Ajustar o intervalo de tempo e a granularidade da análise de correlação para obter uma visão de tendência otimizada ou de grãos grosseiros.
• Em comparação com os dados de preço originais, se você quiser prever as flutuações de preços futuras, talvez precise de mais dados de proporção de quantidade de compra/venda.
• Adicione dados de preços a ações, commodities e moedas fiduciárias para determinar qual delas é relevante para moedas digitais (mas não se esqueça do velho ditado correlação não implica causalidade).
• Use o Registro de Eventos, o GDELT e o Google Trends para quantificar o número de palavras quentes em torno de uma moeda digital específica.
• Usar os dados para treinar um modelo de aprendizagem de máquina preditivo para prever os preços de amanhã.
• Use sua análise para criar um robô de negociação automático, que pode ser aplicado ao site de troca de Poloniex ou Coinbase através da interface de programação de aplicativos (API) correspondente.FMZ.COM) é aqui recomendada.

A melhor parte sobre o Bitcoin e a moeda digital em geral é sua natureza descentralizada, o que o torna mais livre e democrático do que qualquer outro ativo. Você pode compartilhar sua análise open-source, participar da comunidade ou escrever um blog! Espero que você tenha dominado as habilidades necessárias para autoanálise e a capacidade de pensar dialecticamente ao ler quaisquer artigos especulativos de moeda digital no futuro, especialmente aquelas previsões sem suporte de dados. Obrigado por ler. Se você tiver comentários, sugestões ou críticas sobre este tutorial, por favor deixe uma mensagem emhttps://www.fmz.com/bbs.

Relacionados

Mais.