ergoplatform / sigma-rust Goto Github PK

Encode tx with sigmastate and test that it decodes and then encodes to the same JSON.

List if missing nodes is in ergotree-ir/README.md

Create new struct in a separate module(file) in mir module and add it to Expr enum.

Serialization

• Implement SigmaSerializable trait and add node's op code in serialization::expr;
• Implement Arbitrary trait and add serialization roundtrip PBT test for this node;

Evaluation

• Implement Evaluable trait in ergotree-interpreter crate;
• Add evaluation tests;

Checkout implemented IR nodes (Fold, ByIndex) for implementation details.

Sigmastate has it covered in:
https://github.com/ScorexFoundation/sigmastate-interpreter/blob/ec71a6f988f7412bc36199f46e7ad8db643478c7/sigmastate/src/test/scala/sigmastate/serialization/GroupElementSerializerSpecification.scala#L8-L16

REST API endpoint blocks/lastHeaders/{count}.

Most of the users will probably want it enabled.
Include it in default features.

Along or after the #42.

Todo:

• add doc comments;
• extract types and functions from lib.rs into modules;

Implement and enable test(disabled).

Todo:

• go through the checklist in https://doc.rust-lang.org/cargo/reference/publishing.html
• add LICENSE file in npm module;
• check conformance to https://rust-lang.github.io/api-guidelines/
• build and check rust and npm module docs;

It would be great to put readme for project setup and project use.

Implement the use case of parsing P2PK/P2S from string and get bytes.

in

Implement checked arithmetic ops (catch overflow, negative results, etc.).

Following peace of code

    let encoder = sigma_tree::chain::AddressEncoder::new(sigma_tree::chain::NetworkPrefix::Mainnet);
    let address = encoder.parse_address_from_str("9hzP24a2q8KLPVCUk7gdMDXYc7vinmGuxmLp5KU7k9UwptgYBYV").unwrap();

    let contract = sigma_tree::chain::Contract::pay_to_address(address).unwrap();
   let bytes = &contract.get_ergo_tree().sigma_serialise_bytes();

returns bytes

[
    0,  0,   8, 205,   3,  51,  44, 148,  61,
  231, 78, 149,   5,  42,  24, 133, 168, 248,
   27, 78, 229, 222, 113,  89, 161, 129,  66,
  225, 90,  46, 207,  24, 205,  23,   3, 104,
  219
]

It seems that first zero byte is redundant

The following workflow should be supported:

1. Create a box (with P2PK contract);
2. Create a transaction;
3. Specify transaction inputs;
4. Sign created transaction;
5. Serialize the signed transaction to JSON.

Extracted from #50
On JSON deserialization check generated box id with the value in JSON.

Serialize ergo tree to bytes and encode as Base16.

TxBuilder:

• Token minting;
• Token support in BoxSelector;
• Burning tokens;

ErgoBoxCandidateBuilder:

• read/write;

WASM ErgoBox/ErgoBoxCandidate:

• read;

Use cases:

• read box register values;
• set box register values;

Scope

Implement an API feature-wise on par with Wasm bindings (ergo-lib-wasm). Basically an API that a wallet would need to be able to send and receive coins and tokens including input box selection, output box creation and transaction building and signing.

Architecture

The core part is the common/shared source code with JNI (ergo-lib-jni) that should be implemented in ergo-lib-c-core crate.
The generic C bindings should be implemented in ergo-lib-c which should be used in Swift wrapper that should be implemented in ergo-lib-ios.

C

The main idea is to pass Rust types wrapped in opaque pointers and expose functions to manipulate them on C side.
The crucial part is to free resources on the same side(usually Rust) where they were allocated. For this we need to expose a separate function for every "resource-producing" function that frees a resource passed from C. In case of Address see address_from_testnet and address_delete.

Use the already implemented Address type as an example.

Swift

Wraps functions from ergo-lib-c in classes for resource management and exposes methods converting to/from Swift types where necessary.

Types

Using Wasm bindings as a reference we need the following types(with methods) implemented. For implmentation details see Wasm types and their methods in ergo-lib-wasm. Some method names are adopted for C types. See implemented Address type

Wallet:
from_secrets
sign_transaction

SecretKey:
dlog_from_bytes
to_bytes

ErgoStateContext:
new(from PreHeader)

PreHeader:
from_block_header

BlockHeader:
from_json

BlockHeaders:
from_json

UnsignedTransaction:
id
inputs
data_inputs
output_candidates
to_json
from_json

ErgoBox:
new
box_id
creation_height
tokens
ergo_tree
value
register_value
to_json
from_json

ErgoBoxCandidate:
creation_height
tokens
ergo_tree
value
register_value

Token:
new
id
amount

TokenId:
from_box_id
from_str
to_str

TokenAmount:
from_int64_t
as_int64_t

BoxValue:
from_int64_t
as_int64_t

Transaction:
id
to_json
from_json
inputs
data_inputs
output_candidates
outputs

DataInput:
new
box_id

TxBuilder:
new
set_data_inputs
build
box_selection
data_inputs
output_candidates
current_height
fee_amount
change_address
min_change_value

ErgoBoxCandidateBuilder:
new
set_min_box_value_per_byte
min_box_value_per_byte
set_value
value
calc_box_size_bytes
calc_min_box_value
set_register_value
register_value
delete_register_value
mint_token
add_token
build

BoxSelection:
new
boxes
change

SimpleBoxSelector:
select

ErgoBoxAssetsData:
new
value
tokens

Collections

The following types represent a simple wrapper for Vec. Feel free to explore the idea to use the single type (pointer+size) since Rust arrays and slices have the same representation in C (arrays).

ErgoBoxCandidates;
Tokens;
DataInputs;
ErgoBoxAssetsDataList;
SecretKeys;
ErgoBoxes (instead of UnspentBoxes, OutputBoxes, DataInputBoxes)

All of them should implement the following methods:
new
len
get
add

The ErgoBoxes type should implement from_boxes_json method (see Wasm).

Implementation pulled from https://github.com/C4K3/peekable-reader-rs/blob/master/src/lib.rs
in #24
Check the tests there and implement/move the relevant tests.

Consider implementing Into<String> for all Digest32 based identifiers.

The following workflow should be supported:

1. Create a box (with P2PK contract);
2. Create a transaction;
3. Specify transaction inputs;
4. Sign created transaction;
5. Serialize the signed transaction to JSON.

see

Todo:

• implement fiat_shamir_tree_to_bytes();
• implement dlog_protocol::interactive_prover::second_message();
• implement serialize_sig();
• implement verifier;
• test generated proof in verifier;

String might be the best choice. Check out byte array.

I suppose taking some serialized random keys in sigmastate and check that Rust implementation produces the same result is enough.

Implementation in Rust:

In sigmastate:
https://github.com/ScorexFoundation/sigmastate-interpreter/blob/ec71a6f988f7412bc36199f46e7ad8db643478c7/sigmastate/src/main/scala/sigmastate/serialization/GroupElementSerializer.scala#L7-L48

Needed for proposition serialization in prover step 7 in #11