The rust-byron-cardano from input-output-hk

storage: forward iterator

leverage epoch's refpack to implement a forward iterator from a given (epoch_id, slot_id).

update the wallet configuration

A wallet has an associated directory with directory name the name of the wallet.
It contains a config file config.yml:

blockchain: the associated blockchain/network

And up to 2^31 account files account-<index>.yml containing the account state:

alias: account alias for UX, can't be a number to avoid clashing with index, it is optional, in this case user can refer to it via its number;
addresses: array of known addresses
balance: the account balance

remove storage compression and flate2 dependency

add a way to deconvert compressed pack

add a way to download all utxo associated with a specific epoch

create utxopack using accum dumping each new epoch apart from 0
add route in hermes to serve them

Sign/Verify transactions

add LOCK file in storage

have ariadne and hermes to consume this to be able to prevent access to same file and corrupting data.

block genesis storage "compression"

add a special storage representation of the highly information redundant bootstrap era genesis

more block validation

Add some further blocks validation (header, body, proofs, etc)

We can see this as multi level validation (each back by their own function):

At the block level: check that the block is consistent with itself:
- all hashes matches: e.g. body hash matches the one in the header, but other hashes also.
- transactions semantic are correct: at least 1 input, at least 1 output, input sum matches output sum and fees, check fees according to a fee calculator
- etc
At the epoch level: check that all the block within an epoch are valid:
- signature verified
- slot leaders keys (available in genesis block), matches each block signature.
Overall: check that utxo spent are valid.

[hermes] listen to the protocol and make epoch pack

subscribe and/or download latest known blocks
pack done epoch when reaching epoch stability (k, plus margin of safety)

Create transaction

spending protocol

gather information on how it's done
add support for lowlevel protocol

split network protocol parsing/generation from OS part

separate the OS related part from the pure network packet parsing and generation

block encoding unimplemented methods

some block types (Body on genesis and normal, etc) are missing the encoding method (unimplemented)

create sequential address generation based on bip44 and cardano-specs proposal

Add installation instructions

Hey, im just installing this on my machine and it would be great if you add the following installation instructions to the readme:

# install rustup
curl https://sh.rustup.rs -sSf | sh
# use nightly version
rustup install nightly
rustup default nightly
# with wasm32 target
rustup target add wasm32-unknown-unknown --toolchain nightly

Only then i can run ./build correctly 😉

Update configuration of hermes

we need the configuration to allow
- port to listen to
- log level
- log output
- allow override via command line
we need to be able to serve multiple blockchains
- support for the exe-common::config;
- update handlers to serve the different blockchains

by default, we will use the ~/.hermes directory:

.hermes
   |-config.yml
   `-networks
      |-mainnet
      |   |-config.yml
      |   |-blocks
      |   `- ... # all like ariadne here
      `-testnet
          |-config.yml

block genesis finish parsing / printing

Finish parsing of genesis blocks (body), and oretty printing of block

command to retrieve the IP addresses from the DNS and from the peer to peer network

ariadne network discover

depends on #95

subscription protocol

allow receiving async blocks from the network through the subscribe packet

provide API for addresses recovery of sequential addresses

we need to provide an API with the following spec:

input: addressing and n number of following indexes to generate;
output: array of the n generated addresses.

perform some wallet root caching at the wallet level

[suggestion] specify engines in package.json

Hi. I would suggest to specify node and npm/ yarn version in the package.json. https://docs.npmjs.com/files/package.json#engines

have the ability to query the DNS system for resolving to IPs

wallet state tracking

TBD

Ready made transaction to send to network

From UTXO & Sending Targets, create a valid transaction signed and with correct fees

spending support

Add CLI support for spending
depends on #85

protocol configuration API

put all the general configuration in a structure and add as parameter for every functions that requires it

module.alloc is not a function exception

module.alloc is not a function

wallet update: verify signature in block when spending an utxo

merge blockchain and wallet-crypto

release 1.2 to nodejs.com

when Milestone 2 is finished, we can publish a new release of the JS glue to nodejs.com

wallet: add the ability to mark an account readonly/frozen

the account will not be used when spending this way

nix env for building and running hermes

add a nixos "thing" to run hermes as a service on a nixos system

@nc6 could you help with this ?

signing transaction JS-glue API

follow up on #32 : adding the JS glue to sign the transaction, I am in touch with JS team regarding this

fix Tx -> TxId

currently missing a hash in id:

impl Tx { ...
    pub fn id(&self) -> TxId {
}}```

Fee stabilisation algorithm

Fix Base58 decoder

use tokio/future for native network protocol

move from direct use of network primitive to tokio/futures in the network package.

Add support for block and epoch downloading from hermes

through using hyper, add downloading epoch/block APIs

epoch download (done in #106)
block download
tip download

enum Log {
    // keep empty for now
}
impl Log {
    fn serialise(&self) -> Vec<u8> { /* ... */ }
    fn deserialise(bytes: &[u8]) -> Result<Self> { /* ... */ }
}

struct LogReader(AppendReader);
impl LogReader {
    pub fn next(&mut self) -> Result<Option<Log>> { /* ... */ }
}

struct LogWriter(AppendWriter);
impl LogWriter {
    pub fn append(&mut self, log: &Log) -> Result<()> { /* ... */ }
}

wasm JSON-RPC interfaces core API

provide a better/simpler bridge of communication between rust and wasm client

storage append file

leverage the lock file from #113 to prevent concurrent access between processes

impl abstraction to write an append file based on the model of the pack file.

Writing in the append file

let lock = Lock::lock("path/to/file");
let appender = AppendWriter::open(lock);
appender.append(bytes);

Reading from the append file

let lock = Lock::lock("path/to/file");
let mut appender = AppendReader::open(lock);
while let Some(bytes) = appender.pop() {
    // do something
}

Error for existing blockchain

$ RUST_BACKTRACE=1 ./target/debug/ariadne blockchain sync foo
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Message("missing field `peers`", Some(Pos { marker: Marker { index: 10, line: 2, col: 6 }, path: "." }))', libcore/result.rs:945:5
stack backtrace:
   0: std::sys::unix::backtrace::tracing::imp::unwind_backtrace
             at libstd/sys/unix/backtrace/tracing/gcc_s.rs:49
   1: std::sys_common::backtrace::print
             at libstd/sys_common/backtrace.rs:71
             at libstd/sys_common/backtrace.rs:59
   2: std::panicking::default_hook::{{closure}}
             at libstd/panicking.rs:211
   3: std::panicking::default_hook
             at libstd/panicking.rs:227
   4: std::panicking::rust_panic_with_hook
             at libstd/panicking.rs:463
   5: std::panicking::begin_panic_fmt
             at libstd/panicking.rs:350
   6: rust_begin_unwind
             at libstd/panicking.rs:328
   7: core::panicking::panic_fmt
             at libcore/panicking.rs:71
   8: core::result::unwrap_failed
             at /checkout/src/libcore/macros.rs:26
   9: <core::result::Result<T, E>>::unwrap
             at /checkout/src/libcore/result.rs:782
  10: exe_common::config::net::Config::from_file
             at ./exe-common/src/config.rs:227
  11: ariadne::command::blockchain::net_sync_faster
             at wallet-cli/src/command/blockchain/mod.rs:105
  12: <ariadne::command::blockchain::Blockchain as ariadne::command::HasCommand>::run
             at wallet-cli/src/command/blockchain/mod.rs:274
  13: ariadne::main
             at wallet-cli/src/main.rs:43
  14: std::rt::lang_start::{{closure}}
             at /checkout/src/libstd/rt.rs:74
  15: std::panicking::try::do_call
             at libstd/rt.rs:59
             at libstd/panicking.rs:310
  16: __rust_maybe_catch_panic
             at libpanic_unwind/lib.rs:105
  17: std::rt::lang_start_internal
             at libstd/panicking.rs:289
             at libstd/panic.rs:374
             at libstd/rt.rs:58
  18: std::rt::lang_start
             at /checkout/src/libstd/rt.rs:74
  19: main
  20: __libc_start_main
  21: _start
             at ../sysdeps/x86_64/start.S:120

Error for new blockchain (repro)

$ RUST_BACKTRACE=1 ./target/debug/ariadne blockchain new --template testnet foo2

$ RUST_BACKTRACE=1 ./target/debug/ariadne blockchain sync foo2
Configured genesis   : b365f1be6863b453f12b93e1810909b10c79a95ee44bf53414888513fe172c90
Configured genesis-1 : c6a004d3d178f600cd8caa10abbebe1549bef878f0665aea2903472d5abf7323
latest known epoch 0 hash=Some(HeaderHash(b365f1be6863b453f12b93e1810909b10c79a95ee44bf53414888513fe172c90))
downloading epoch 0 b365f1be6863b453f12b93e1810909b10c79a95ee44bf53414888513fe172c90
 INFO 2018-05-31T16:51:01Z: exe_common::network::hermes: querying uri: http://hermes.dev.iohkdev.io/foo2/epoch/0
 INFO 2018-05-31T16:51:01Z: exe_common::network::hermes: Downloaded EPOCH in 0sec
thread 'main' panicked at 'no last block found, error.', exe-common/src/network/hermes.rs:79:23
stack backtrace:
   0: std::sys::unix::backtrace::tracing::imp::unwind_backtrace
             at libstd/sys/unix/backtrace/tracing/gcc_s.rs:49
   1: std::sys_common::backtrace::print
             at libstd/sys_common/backtrace.rs:71
             at libstd/sys_common/backtrace.rs:59
   2: std::panicking::default_hook::{{closure}}
             at libstd/panicking.rs:211
   3: std::panicking::default_hook
             at libstd/panicking.rs:227
   4: std::panicking::rust_panic_with_hook
             at libstd/panicking.rs:463
   5: std::panicking::begin_panic
             at /checkout/src/libstd/panicking.rs:397
   6: <exe_common::network::hermes::HermesEndPoint as exe_common::network::api::Api>::fetch_epoch
             at exe-common/src/network/hermes.rs:79
   7: <exe_common::network::peer::Peer as exe_common::network::api::Api>::fetch_epoch
             at exe-common/src/network/peer.rs:44
   8: ariadne::command::blockchain::net_sync_faster
             at wallet-cli/src/command/blockchain/mod.rs:132
   9: <ariadne::command::blockchain::Blockchain as ariadne::command::HasCommand>::run
             at wallet-cli/src/command/blockchain/mod.rs:274
  10: ariadne::main
             at wallet-cli/src/main.rs:43
  11: std::rt::lang_start::{{closure}}
             at /checkout/src/libstd/rt.rs:74
  12: std::panicking::try::do_call
             at libstd/rt.rs:59
             at libstd/panicking.rs:310
  13: __rust_maybe_catch_panic
             at libpanic_unwind/lib.rs:105
  14: std::rt::lang_start_internal
             at libstd/panicking.rs:289
             at libstd/panic.rs:374
             at libstd/rt.rs:58
  15: std::rt::lang_start
             at /checkout/src/libstd/rt.rs:74
  16: main
  17: __libc_start_main
  18: _start
             at ../sysdeps/x86_64/start.S:120

specify derivation scheme and recovery mechanism

Add specs related to:

seed generation
derivation indices
derivation schemes
recovery mechanism

input-output-hk / rust-byron-cardano Goto Github PK

rust-byron-cardano's Introduction

Rust implementation of Cardano primitives, helpers, and related applications

Related repositories

Installation

Building the Library

Running the tests

How to integrate the Rust library in your project

rust-byron-cardano's People

Contributors

Stargazers

Watchers

Forkers

rust-byron-cardano's Issues

Writing in the append file

Reading from the append file

Error for existing blockchain

Error for new blockchain (repro)

Recommend Projects

Recommend Topics

Recommend Org