Anteriormente, compartilhamos uma postagem sobre Como monitorar os ativos da Stellar usando o Couchbase. Neste acompanhamento, demonstraremos como carregar transações recentes de blockchain da Stellar (por exemplo, negociações) em nosso Capella DBaaS, tornando-as facilmente acessíveis para uso em aplicativos de amostra. Com a interface de gerenciamento da Web incorporada do Capella, você pode executar consultas de teste, explorar documentos e realizar várias outras tarefas para interagir com os dados do blockchain de forma perfeita.
O que são negociações Stellar?
A Stellar é uma plataforma de blockchain descentralizada projetada para transações rápidas, seguras e de baixo custo. Para desenvolvedores e engenheiros de back-end de banco de dados, a Stellar oferece uma oportunidade única de criar aplicativos financeiros que podem lidar com pagamentos internacionais, micropagamentos e ativos tokenizados em escala. O que diferencia a Stellar é o seu algoritmo de consenso, o Stellar Consensus Protocol (SCP), que oferece uma alternativa mais eficiente em termos de energia às blockchains tradicionais de prova de trabalho. Isso permite que os desenvolvedores integrem a funcionalidade do blockchain sem comprometer a velocidade ou a escalabilidade.
A API e os SDKs da Stellar suportam uma ampla gama de linguagens de programação, facilitando a criação, a conexão e o gerenciamento de aplicativos apoiados por blockchain dentro das infraestruturas de banco de dados existentes. Ao aproveitar o Stellar, os desenvolvedores podem trazer o poder das finanças descentralizadas (DeFi) para seus sistemas com o mínimo de atrito e o máximo de impacto.
Estelar negócios são operações que ocorrem no blockchain da Stellar, facilitando a transferência de ativos entre contas ou interagindo com a rede de várias maneiras. Cada transação é composta por um conjunto de operações e requer autorização do titular da conta que a iniciou por meio de uma assinatura digital. O Stellar suporta vários tipos de operações em uma única transação, o que o torna altamente versátil.
Os principais aspectos das transações da Stellar incluem:
-
- Transferência de ativos: A Stellar permite a transferência de qualquer tipo de ativo, incluindo XLM (Lumens) nativo e moedas fiduciárias tokenizadas, entre contas.
- Pagamentos por caminho: Esse recurso permite que os usuários enviem um tipo de ativo enquanto o destinatário recebe outro. O câmbio descentralizado da Stellar (DEX) encontra automaticamente o melhor caminho de câmbio para facilitar a conversão.
- Criação e gerenciamento de contas: As transações podem criar novas contas, atribuir saldos iniciais e definir vários parâmetros de conta, como linhas de confiança (para aceitar novos tipos de ativos).
- Contratos inteligentes (Multi-Sig): Embora a Stellar não tenha contratos inteligentes tradicionais, como a Ethereum, ela oferece suporte a transações com várias assinaturas e operações com bloqueio de tempo, permitindo cenários de transação mais complexos, como configurações do tipo escrow.
- Emissão e negociação de ativos: A Stellar permite que qualquer pessoa emita ativos personalizados (como tokens) e os negocie em sua DEX. Os desenvolvedores podem tokenizar ativos e fornecer liquidez para pares de negociação.
- Estrutura de taxas: As transações Stellar são projetadas para serem rápidas e de baixo custo, com taxas de apenas frações de um centavo (denominadas em XLM). Isso é particularmente vantajoso para aplicativos que exigem alta taxa de transferência de transações e custos indiretos mínimos.
Para os desenvolvedores, as transações Stellar oferecem uma maneira fácil de interagir com ativos digitais e integrar funcionalidades descentralizadas aos aplicativos, ao mesmo tempo em que se beneficiam dos tempos de confirmação rápidos e das baixas taxas do blockchain.
Como carregar dados históricos do Stellar a partir do Horizon Server usando Python
O serviço Stellar Horizon desempenha um papel vital no ecossistema Stellar, servindo como ponte entre os desenvolvedores e a rede Stellar. Ao fornecer uma API RESTful, ele permite que os aplicativos interajam facilmente com o blockchain do Stellar sem precisar acessar diretamente os nós subjacentes do Stellar Core. Essa abstração simplifica o processo para os desenvolvedores, tornando mais simples a criação e a integração de recursos baseados em blockchain.
O Horizon lida com várias funções essenciais para a interação com o blockchain. Ele permite que os desenvolvedores enviem transações, validem-nas e as encaminhem ao Stellar Core para processamento. Além disso, ele oferece acesso a informações detalhadas da conta, como saldos, histórico de transações e linhas de confiança, o que simplifica a recuperação e a exibição de dados. O Horizon também permite que os desenvolvedores consultem o livro-razão Stellar para transações passadas e detalhes operacionais, servindo como um gateway fácil de usar para acessar dados de blockchain históricos e em tempo real.
Neste exemplo, vamos analisar apenas as negociações e a precificação de ativos com base no histórico de negociações. Os documentos de negociações, retornados do Horizon como JSON, têm a seguinte aparência:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
{ "_links": { "self": { "href": "" }, "base": { "href": "https://horizon.stellar.org/liquidity_pools/94b45fd827c6d0a420032d600e8738625efd0ee7c6e4d6345cb184ee6e153ebb" }, "contador": { "href": "https://horizon.stellar.org/accounts/GD65FION32RSQYIHDSQU3ZNMHWCFQ4KVILQYDFGFWI3NCCZXQG265EXP" }, "operação": { "href": "https://horizon.stellar.org/operations/202488814445412353" } }, "id": "202488814445412353-0", "paging_token": "202488814445412353-0", "ledger_close_time": "2023-07-11T02:54:21Z", "trade_type": "liquidity_pool", "liquidity_pool_fee_bp": 30, "base_liquidity_pool_id": "94b45fd827c6d0a420032d600e8738625efd0ee7c6e4d6345cb184ee6e153ebb", "base_amount": "0.0000003", "base_asset_type": "nativo", "counter_offer_id": "4814174832872800257", "counter_account": "GD65FION32RSQYIHDSQU3ZNMHWCFQ4KVILQYDFGFWI3NCCZXQG265EXP", "counter_amount": "11.0000000", "counter_asset_type": "credit_alphanum4", "counter_asset_code": "wSHX", "counter_asset_issuer": "GDAPJ5EVAXUU5ZLDHBUQF3MA5EV7S44T3AJPY42LMSD6ZZKQOQIAWSHX", "base_is_seller": verdadeiro, "price" (preço): { "n": "110000000", "d": "3" } } |
Nosso script Python fará o download das negociações mais recentes e carregará os documentos no Capella.
Requisitos para conexão com o Horizon e o Couchbase
O Couchbase e o Stellar têm alguns requisitos antes de podermos executar nosso script:
-
- Usamos o Python estelar_sdk módulo. Nos exemplos anteriores, usamos solicitações/fetchs HTTP básicos, mas, dessa forma, podemos manter o código simples e usar as bibliotecas compatíveis. Instale com
pip install stellar-sdk. - Se quiser examinar apenas as negociações relacionadas a determinados ativos, você precisará conhecer os identificadores de ativos previamente. O código do ativo identifica o ativo específico que está sendo negociado, enquanto o emissor de ativos especifica a conta Stellar que emitiu o ativo, garantindo sua autenticidade e origem.
- Cuidado: ambos os elementos são essenciais para identificar o ativo correto ao negociar!
- Para se conectar à Capella, você precisa ter uma conta - Inscreva-se em uma conta Capella gratuita hoje mesmo, sem obrigações.
- Seu cluster deve ter um bucket chamado estelar.
- Você também deve saber o URL de conexão do bucket com o qual está trabalhando.
- O acesso ao cluster também deve ser ativado com um nome e uma senha.
- Essas configurações podem ser acessadas por meio da interface de gerenciamento do Capella.
- Salve essas configurações em um arquivo local_settings.py que chamaremos com nosso script:
1234ponto final = "couchbases://cb.xlzvmx....jom.cloud.couchbase.com"nome de usuário = "nome de usuário do cluster"senha = "clusterpassword" (senha do cluster)balde = "estelar"
- Usamos o Python estelar_sdk módulo. Nos exemplos anteriores, usamos solicitações/fetchs HTTP básicos, mas, dessa forma, podemos manter o código simples e usar as bibliotecas compatíveis. Instale com
Acesso aos dados do Stellar Horizon com Python
Com o acima exposto, aqui está um exemplo da função de código básico para capturar negociações, opcionalmente filtrando por código do ativo ou emissor de ativos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
def buscar e armazenar negociações(código do ativo=Nenhum, emissor de ativos=Nenhum): servidor = Servidor(horizon_url=HORIZON_URL) construtor_de_chamadas_comerciais = servidor.negócios().limite(MAX_TRANSACTIONS) tentar: trades_response = construtor_de_chamadas_comerciais.chamada() negócios = trades_response['_embedded']['registros'] # Filtrar manualmente as negociações com base no código do ativo e no emissor se código do ativo e emissor de ativos: filtered_trades = [ comércio para comércio em negócios se ( (comércio.obter('base_asset_code') == código do ativo e comércio.obter('base_asset_issuer') == emissor de ativos) ou (comércio.obter('counter_asset_code') == código do ativo e comércio.obter('counter_asset_issuer') == emissor de ativos) ) ] mais: filtered_trades = negócios # Calcular o preço como um número de ponto flutuante para comércio em filtered_trades: preço_n = flutuar(comércio['preço']['n']) preço_d = flutuar(comércio['preço']['d']) comércio['price_number'] = preço_n / preço_d upload_to_couchbase(filtered_trades, COUCHBASE_BUCKET) exceto Exceção como e: impressão(f"Ocorreu um erro ao buscar negociações: {e}") |
Decodificando o preço de negociação do ativo Stellar
Para este exemplo, estamos especificamente interessados em três conjuntos de informações mostrados no documento de amostra anterior:
-
- asset_code & asset_issuer - linhas 28-29 no documento de amostra
- valor negociado - linha 26
- preços de negociação - as linhas 31-34 nos informam qual foi o preço do ativo durante a negociação e são mantidas em um objeto JSON chamado preço:{}
Os dois primeiros conjuntos de dados são atributos diretos que podemos usar como estão. Mas os preços são um pouco mais complicados. Os preços no Stellar têm uma precisão muito alta e não usam apenas floats. Em vez disso, eles usam um numerador e um denominador que são divididos, conforme necessário, para produzir um preço de ponto flutuante. Portanto, conforme mostrado no exemplo de código, na linha 25, calculamos um novo atributo a ser salvo no documento antes de ele ser carregado no banco de dados.
trade['price_number'] = price_n / price_d
Você pode usar o mesmo padrão para adicionar qualquer tipo de atributo necessário, como data de download, nome do projeto etc.
Agora que temos o documento comercial, adicionamos nosso número de preço de aparência normal e podemos carregá-lo no banco de dados com nosso código de função de upload.
Upload de documentos para o Capella com Python
Há algumas abordagens para carregar e/ou atualizar documentos no Capella. Nesse caso, usamos a função upsert para adicionar ou substituir documentos com o mesmo ID. Pegamos a ID diretamente do atributo de ID da negociação, de modo que nossa chave personalizada flexível para nossos documentos possa refletir exatamente o Horizon. Isso é útil para o alinhamento futuro com os dados históricos do Horizon à medida que você dimensiona seu sistema.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
def upload_to_couchbase(dados, nome_do_balde): tentar: # Conectar-se ao cluster do Couchbase timeout_options = ClusterTimeoutOptions(kv_timeout=tempo decorrido(segundos=10)) agrupamento = Aglomerado( CLUSTER DE BASE DE SOFÁ, ClusterOptions(PasswordAuthenticator(NOME DE USUÁRIO DO COUCHBASE, COUCHBASE_PASSWORD), timeout_options=timeout_options) ) balde = agrupamento.balde(nome_do_balde) coleção = balde.default_collection() # Inserir os dados (sobrescrever se a chave existir) para comércio em dados: chave = comércio['id'] coleção.upsert(chave, comércio) impressão(f"Os dados foram carregados no bucket do Couchbase '{bucket_name}'") exceto CouchbaseException como e: impressão(f"Ocorreu um erro ao fazer o upload para o Couchbase: {e}") |
O roteiro completo está incluído aqui, clique para expandir:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 |
importação argparse importação solicitações importação json de data e hora importação tempo decorrido de couchbase.agrupamento importação Aglomerado de couchbase.autenticação importação PasswordAuthenticator de couchbase.opções importação ClusterOptions, ClusterTimeoutOptions de couchbase.exceções importação CouchbaseException de estelar_sdk.servidor importação Servidor importação configurações locais como capela # Definir o ponto de extremidade da API do Horizon HORIZON_URL = "https://horizon.stellar.org" MAX_TRANSACTIONS = 100 # Número de transações a serem recuperadas BATCH_SIZE = 200 # Número de transações por solicitação (máximo permitido pela API) # Detalhes da conexão do Couchbase CLUSTER DE BASE DE SOFÁ = capela.ponto final COUCHBASE_BUCKET = capela.balde NOME DE USUÁRIO DO COUCHBASE = capela.nome de usuário COUCHBASE_PASSWORD = capela.senha def buscar e armazenar negociações(código do ativo=Nenhum, emissor de ativos=Nenhum): servidor = Servidor(horizon_url=HORIZON_URL) construtor_de_chamadas_comerciais = servidor.negócios().limite(MAX_TRANSACTIONS) tentar: trades_response = construtor_de_chamadas_comerciais.chamada() negócios = trades_response['_embedded']['registros'] # Filtrar manualmente as negociações com base no código do ativo e no emissor se código do ativo e emissor de ativos: filtered_trades = [ comércio para comércio em negócios se ( (comércio.obter('base_asset_code') == código do ativo e comércio.obter('base_asset_issuer') == emissor de ativos) ou (comércio.obter('counter_asset_code') == código do ativo e comércio.obter('counter_asset_issuer') == emissor de ativos) ) ] mais: filtered_trades = negócios # Calcular o preço como um número de ponto flutuante para comércio em filtered_trades: preço_n = flutuar(comércio['preço']['n']) preço_d = flutuar(comércio['preço']['d']) comércio['price_number'] = preço_n / preço_d upload_to_couchbase(filtered_trades, COUCHBASE_BUCKET) exceto Exceção como e: impressão(f"Ocorreu um erro ao buscar negociações: {e}") def upload_to_couchbase(dados, nome_do_balde): tentar: # Conectar-se ao cluster do Couchbase timeout_options = ClusterTimeoutOptions(kv_timeout=tempo decorrido(segundos=10)) agrupamento = Aglomerado( CLUSTER DE BASE DE SOFÁ, ClusterOptions(PasswordAuthenticator(NOME DE USUÁRIO DO COUCHBASE, COUCHBASE_PASSWORD), timeout_options=timeout_options) ) balde = agrupamento.balde(nome_do_balde) coleção = balde.default_collection() # Inserir os dados (sobrescrever se a chave existir) para comércio em dados: chave = comércio['id'] coleção.upsert(chave, comércio) impressão(f"Os dados foram carregados no bucket do Couchbase '{bucket_name}'") exceto CouchbaseException como e: impressão(f"Ocorreu um erro ao fazer o upload para o Couchbase: {e}") def principal(): analisador = argparse.ArgumentoParser(descrição="Obtenha negociações do Stellar e armazene no Couchbase.") analisador.add_argument('--asset_code', tipo=str, ajuda=O código do ativo para filtrar as negociações.) analisador.add_argument('--asset_issuer', tipo=str, ajuda=O emissor do ativo para filtrar as negociações.) argumentos = analisador.parse_args() buscar e armazenar negociações(argumentos.código do ativo, argumentos.emissor de ativos) se __name__ == "__main__": principal() |
Visualização de documentos em Capella
Ir para o Ferramentas de dados no Capella e defina a guia Balde para estelar e usar Padrão para o escopo e a coleção.
Os documentos são listados e você pode clicar no campo numérico azul ID DO DOC para ver o documento completo e, em seguida, role a tela para baixo para ver as informações sobre preços:
Consulta de negociações de blockchain da Stellar no Capella
Agora que os dados estão no Capella, podemos indexá-los e consultá-los. Mas vamos tentar isso de uma forma não convencional, executando nossa consulta primeiro. O Capella é inteligente e pode sugerir quais índices precisam ser feitos. Portanto, quando você executa uma consulta e ele percebe que poderia otimizá-la ainda mais, ele faz sugestões. Você aceita a sugestão e pode continuar.
Ir para o Ferramentas de dados -> Consulta e selecione o bucket Stellar no menu suspenso acima da janela de consulta.
Apague a consulta padrão e insira esta para obter uma lista de negociações com seus IDs, preço e o preço que o Python calculou, juntamente com os cálculos de preço em tempo real dentro da linguagem de consulta Capella SQL++:
|
1 2 3 4 5 6 |
SELECIONAR id, preço, preço.n AS número_de_preço, TONUMBER(preço.n) / TONUMBER(preço.d) AS price_calc DE estelar.Padrão.Padrão |
Como você pode ver, esse SQL básico, embora você possa ver no DE que poderíamos ter escopo, coleções e subconjuntos de documentos, se quiséssemos.
Os resultados são listados em JSON por padrão, abaixo, ou você pode optar por vê-los em uma tabela. O Capella é poderoso porque pode mostrar objetos JSON dentro de documentos e não apenas tipos de campos básicos normalmente usados em bancos de dados SQL, observe o preço objeto.
Criar índices para negociações
O Capella fornece automaticamente conselhos sobre indexação no canto superior direito. Há também uma guia no canto central direito da tela, caso ela esteja se escondendo de você.
Escolha Sugestão de construção e suas consultas serão executadas muito mais rapidamente - as minhas passaram de 600 ms para 6 ms após a indexação.
Este vídeo mostra uma interação semelhante em uma exibição ao vivo, para que você possa vê-la em ação, embora use um conjunto de dados diferente:
E agora?
Continue criando seus aplicativos usando a versão gratuita do Capella, bastando inscrição ou pegue um pacote inicial e também obterá grandes descontos em créditos de nuvem e suporte avançado da equipe do Couchbase.
