A Rust library which makes interacting with and using an Ergo Node simple.
This crate uses the great ergo-lib (formerly sigma-rust) for parsing the ErgoBoxes from the Ergo Node and other Ergo-related data-types.
Currently supported features include: 1. Core Ergo Node endpoints for writing off-chain dApps. 2. Helper functions on top of the supported endpoints which simplify the dApp developer experience. 3. A higher level interface for UTXO-set scanning.
100% of all Ergo Node endpoints are not supported in the present version, as the current goal is to focus on making the off-chain dApp developer experience as solid as possible. Full endpoint coverage is indeed a goal for the long-term nonetheless.
The below are the currently implemented modules part of the Ergo Node Interface library.
This module contains the core NodeInterface struct which is used to interact with an Ergo Node. All endpoints are implemented as methods on the NodeInterface struct.
rust
let node = NodeInterface::new(api_key, ip, port);
println!("Current height: {}", node.current_block_height());
Furthermore a number of helper methods are implemented as well, such as:
```rust
/// A CLI interactive interface for prompting a user to select an address
pub fn selectwalletaddress(&self) -> Result
/// Returns a sorted list of unspent boxes which cover at least the
/// provided value total of nanoErgs.
/// Note: This box selection strategy simply uses the largest
/// value holding boxes from the user's wallet first.
pub fn unspentboxeswithmintotal(&self, total: NanoErg) -> Result
```
This module contains the Scan struct which allows a developer to easily work with UTXO-set scans. Each Scan is tied to a specific NodeInterface, which is inspired from the fact that scans are saved on a per-node basis.
The Scan struct provides you with the ability to easily:
1. Register new scans with an Ergo Node.
2. Acquire boxes/serialized boxes from your registered scans.
3. Save/read scan ids to/from a local file.
Example using the scanning interface to register a scan to track an Oracle Pool:
```rust let oraclepoolnftid = "08b59b14e4fdd60e5952314adbaa8b4e00bc0f0b676872a5224d3bf8591074cd".tostring();
let trackingrule = object! { "predicate": "containsAsset", "assetId": oraclepoolnftid, };
let scan = Scan::register( &"Oracle Pool Box Scan".tostring(), trackingrule, node, ).unwrap();
```
This module provides a few helper functions to save/read from a local node-interface.yaml file which holds the Ergo Node ip/port/api key. This makes it much quicker for a dApp developer to get their dApp running without having to manually implement such logic himself.
Example functions which are available:
``rust
/// Create a newnode-interface.config` with the barebones yaml inside
pub fn createnewlocalconfigfile() -> Result<()>
/// Opens a local node-interface.yaml file and uses the
/// data inside to create a NodeInterface
pub fn newinterfacefromlocalconfig() -> Result
Documentation can be accessed via running the following command:
rust
cargo doc --open
See CONTRIBUTING