download do nó astrix - download do código-fonte do nó astrix

astrix node

Outro código-fonte

v0.14.1

Baixar

Nó Astrix

Astrix full-node e suas bibliotecas auxiliares.

Convidamos desenvolvedores e entusiastas de blockchain para colaborar, testar e otimizar nossa implementação Rust. Cada linha de código aqui é uma oportunidade de contribuir para o movimento blockchain de código aberto, moldando uma plataforma projetada para escalabilidade e velocidade sem comprometer a descentralização.

Seus comentários, contribuições e relatórios de problemas serão essenciais para a evolução desta base de código e para continuar sua maturidade como um nó confiável na rede Astrix.

Instalação

Construindo no Linux

Instale pré-requisitos gerais

sudo apt install curl git build-essential libssl-dev pkg-config

Instale o Protobuf (necessário para gRPC)

sudo apt install protobuf-compiler libprotobuf-dev # Required for gRPC

Instale o conjunto de ferramentas clang (necessário para compilações RocksDB e WASM secp256k1)

sudo apt-get install clang-format clang-tidy 
clang-tools clang clangd libc++-dev 
libc++1 libc++abi-dev libc++abi1 
libclang-dev libclang1 liblldb-dev 
libllvm-ocaml-dev libomp-dev libomp5 
lld lldb llvm-dev llvm-runtime 
llvm python3-clang

Instale o conjunto de ferramentas de ferrugem
Se você já possui o Rust instalado, atualize-o executando: rustup update
Instale o pacote wasm
```
cargo install wasm-pack
```

Instale o destino wasm32

rustup target add wasm32-unknown-unknown

Clonar o repositório

git clone https://github.com/astrix-network/astrix-node
cd astrix-node

Construindo no Windows

Instale o Git para Windows ou uma distribuição alternativa do Git.
Instale buffers de protocolo e adicione o diretório bin ao seu Path
Instale LLVM-15.0.6-win64.exe
Adicione o diretório bin da instalação do LLVM ( C:Program FilesLLVMbin ) ao PATH
defina a variável de ambiente LIBCLANG_PATH para apontar para o diretório bin também
IMPORTANTE: Devido a problemas de configuração de dependência de C++, a instalação do LLVM AR no Windows pode não funcionar corretamente ao alternar entre WASM e compilação de código C++ nativo (compilações nativas RocksDB+secp256k1 vs WASM32 de secp256k1 ). Infelizmente, definir manualmente a variável de ambiente AR também confunde o conjunto de ferramentas de construção C++ (ela não deve ser definida como nativa, mas deve ser definida para destinos WASM32). Atualmente, a melhor maneira de resolver isso é a seguinte: após instalar o LLVM no Windows, vá para o diretório de instalação bin de destino e copie ou renomeie LLVM_AR.exe para AR.exe .
Instale o conjunto de ferramentas de ferrugem
Se você já possui o Rust instalado, atualize-o executando: rustup update
Instale o pacote wasm
```
cargo install wasm-pack
```

Instale o destino wasm32

rustup target add wasm32-unknown-unknown

Clonar o repositório

git clone https://github.com/astrix-network/astrix-node
cd astrix-node

Construindo no Mac OS

Instale o Protobuf (necessário para gRPC)
```
brew install protobuf
```
Instale o llvm.
A instalação padrão do XCode do llvm não suporta destinos de construção WASM. Para construir o WASM no MacOS, você precisa instalar llvm do homebrew (no momento em que este artigo foi escrito, a versão do llvm para MacOS era 16.0.1).
```
brew install llvm
```
NOTA: O Homebrew pode usar diferentes locais de instalação do barril, dependendo da sua configuração. Por exemplo:
- /opt/homebrew/opt/llvm -> /opt/homebrew/Cellar/llvm/16.0.1
- /usr/local/Cellar/llvm/16.0.1
Para determinar o local de instalação, você pode usar o comando brew list llvm e modificar os caminhos abaixo de acordo:
```
% brew list llvm
/usr/local/Cellar/llvm/16.0.1/bin/FileCheck
/usr/local/Cellar/llvm/16.0.1/bin/UnicodeNameMappingGenerator
...
```
Se você tiver /opt/homebrew/Cellar , poderá usar /opt/homebrew/opt/llvm .
Adicione o seguinte ao seu arquivo ~/.zshrc :
```
 export PATH= " /opt/homebrew/opt/llvm/bin: $PATH "
export LDFLAGS= " -L/opt/homebrew/opt/llvm/lib "
export CPPFLAGS= " -I/opt/homebrew/opt/llvm/include "
export AR=/opt/homebrew/opt/llvm/bin/llvm-ar
```
Recarregue o arquivo ~/.zshrc
```
 source ~ /.zshrc
```
Instale o conjunto de ferramentas de ferrugem
Se você já possui o Rust instalado, atualize-o executando: rustup update
Instale o pacote wasm
```
cargo install wasm-pack
```

Instale o destino wasm32

rustup target add wasm32-unknown-unknown

Clonar o repositório

git clone https://github.com/astrix-network/astrix-node
cd astrix-node

Construindo SDK WASM32

Rust WebAssembly (WASM) refere-se ao uso da linguagem de programação Rust para escrever código que pode ser compilado em WebAssembly, um formato de instrução binária executado em navegadores da web e NodeJs. Isso permite fácil desenvolvimento usando linguagens de programação JavaScript e TypeScript, mantendo os benefícios do Rust.

Os componentes do WASM SDK podem ser compilados a partir de fontes executando: - ./build-release - construir um pacote de lançamento completo (inclui compilações de lançamento e depuração para destinos web e nodejs) - ./build-docs - construir documentação TypeScript - ./build-web - liberar compilação da web - ./build-web-dev - desenvolvimento compilação da web - ./build-nodejs - liberar compilação nodejs - ./build-nodejs-dev - desenvolvimento compilação nodejs

IMPORTANTE: não use compilações dev em produção. Eles são significativamente maiores, mais lentos e incluem símbolos de depuração.

Requisitos

NodeJs (v20+): https://nodejs.org/en
TypeDoc: https://typedoc.org/

Astrix CLI + Carteira

A caixa `astrix-cli` fornece uma interface RPC orientada por CLI para o nó e uma interface de terminal para o tempo de execução do Astrix Node Wallet. Essas carteiras são compatíveis com os projetos WASM SDK Wallet API e Astrix NG.

 cd cli
cargo run --release

Carteira local da Web

Execute um servidor http dentro da pasta wallet/wasm/web . Se você não tiver uma vez, poderá usar o seguinte:

 cd wallet/wasm/web
cargo install basic-http-server
basic-http-server

O servidor http básico servirá na porta 4000 por padrão, então abra seu navegador e carregue http://localhost:4000

A estrutura é compatível com todos os principais navegadores de desktop e móveis.

Executando o nó

Iniciar um nó mainnet

cargo run --release --bin astrixd
# or with UTXO-index enabled (needed when using wallets)
cargo run --release --bin astrixd -- --utxoindex

Usando um arquivo de configuração

cargo run --release --bin astrixd -- --configfile /path/to/configfile.toml
# or
cargo run --release --bin astrixd -- -C /path/to/configfile.toml

O arquivo de configuração deve ser uma lista de = separados por novas linhas.
Espaço em branco ao redor de = é bom, arg=value e arg = value são analisados corretamente.
Valores com caracteres especiais como . ou = exigirá a citação do valor, ou seja, = "".
Argumentos com vários valores devem ser colocados entre colchetes como addpeer = ["10.0.0.1", "1.2.3.4"] .

Por exemplo:

 utxoindex = false
disable-upnp = true
perf-metrics = true
appdir = "some-dir"
netsuffix = 11
addpeer = ["10.0.0.1", "1.2.3.4"]

Passe o sinalizador --help para visualizar todos os argumentos possíveis

cargo run --release --bin astrixd -- --help

wRPC

O subsistema wRPC está desabilitado por padrão no astrixd e pode ser habilitado via:

Protocolo JSON:

--rpclisten-json = < interface:port >
# or use the defaults for current network
--rpclisten-json = default

Protocolo Borsh:

--rpclisten-borsh = < interface:port >
# or use the defaults for current network
--rpclisten-borsh = default

Nota lateral:

Astrix Node integra um subsistema wRPC opcional. wRPC é uma implementação RPC de alto desempenho, plataforma neutra, centrada em Rust e estruturada em WebSocket que pode usar codificação de protocolo Borsh e JSON.

As mensagens do protocolo JSON são semelhantes ao JSON-RPC 1.0, mas diferem da especificação devido às notificações do lado do servidor.

A codificação Borsh destina-se à comunicação entre processos. Ao usar o Borsh, tanto o cliente quanto o servidor devem ser construídos a partir da mesma base de código.

O protocolo JSON é baseado em estruturas de dados Astrix e é independente da versão da estrutura de dados. Você pode se conectar ao endpoint JSON usando qualquer biblioteca WebSocket. Clientes RPC integrados para JavaScript e TypeScript capazes de serem executados em navegadores da web e Node.js estão disponíveis como parte da estrutura Astrix WASM.

Comparativo e testes

Estrutura de simulação (Simpa)

O login no astrixd e simpa pode ser filtrado por:

A base de código atual suporta uma simulação de rede completa em processo, construindo um DAG real em tempo virtual com atraso virtual e tempo de validação de benchmarking (após a geração da simulação).

Para ver os comandos disponíveis

cargo run --release --bin simpa -- --help

O comando a seguir executará uma simulação para produzir 1.000 blocos com atraso de comunicação de 2 segundos e 8 BPS (blocos por segundo) enquanto tenta preencher cada bloco com até 200 transações.

cargo run --release --bin simpa -- -t=200 -d=2 -b=8 -n=1000

Perfil de pilha

O perfil de heap em astrixd e simpa pode ser feito habilitando o recurso e perfil heap usando o argumento --features

cargo run --bin astrixd --profile heap --features=heap

Ele produzirá o arquivo {bin-name}-heap.json na raiz do workdir, que pode ser inspecionado pelo visualizador dhat

Testes

Execute testes unitários e a maioria dos testes de integração

 cd astrix-node
cargo test --release
// or install nextest and run

Usando o próximo

 cd astrix-node
cargo nextest run --release

Referências

 cd astrix-node
cargo bench

Registro

O login no astrixd e simpa pode ser filtrado por:

Definindo a variável de ambiente RUST_LOG

Adicionando o argumento --loglevel como no exemplo a seguir:

 (cargo run --bin astrixd -- --loglevel info,astrix_rpc_core=trace,astrix_grpc_core=trace,consensus=trace,astrix_core=trace) 2>&1 | tee ~/astrix-node.log

Neste comando definimos o loglevel como INFO .

Expandir

Informações adicionais