JSON RPC Client for Lotus

Demonstrate by providing basic code to:

• Request Nonce values for specific accounts

Transaction Parse in the service is still not implemented

https://github.com/Zondax/filecoin-rs/blob/281171de2566390646ab0bb9b32209c6fc352da9/fcservice/src/service/methods.rs#L32

The library has most functionality ready.

transaction_parse should receive a CBOR hexstring and should return json.
The hexstring can be both an unsigned or signed message. The service call should handle both cases automatically.

Please extend jsonrpc tests.

Add support for key generation

• Secp256k1 support
• CBOR serialization / deserialization

Add support for transaction signing and verification

• Use key_derive for the example.
• Add a small section in the documentation
• Adjust circleCI configuration to confirm
  This very likely depends on the Obj-C and Java examples

🔗 zboto Link

Add support for key derivation

Which format signature sign_transaction should return ?

Lotus seems to accept RSV format and forest use DER format (https://chainsafe.github.io/forest/src/crypto/signature.rs.html#164-178) ?

Only one format should be used to avoid confusion.

The following testcase has been disabled but needs to the re-enabled and investigated
ac353a6

In order to improve testing we should add error type for invalid transaction.

Example :

    {
        "description": "Address protocol 2 Invalid payload length of 21 bytes",
        "encoded_tx": "iFYCAAAAAAAAAAAAAAAAAAAAAAAAAAAAVgIAAAAAAAAAAAAAAAAAAAAAAAAAAAABRAABhqBDAAnEQwBhqABA",
        "valid": false,
        "testnet": false,
        "message": {
            "to": "f2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa3sien4",
            "from": "f2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa3sien4",
            "nonce": 1,
            "value": "100000",
            "gas_price": "2500",
            "gas_limit": "25000",
            "method": 0
        },
        "encoded_tx_hex": "88560200000000000000000000000000000000000000000056020000000000000000000000000000000000000000000144000186a0430009c4430061a80040",
   "error": "Invalid payload"
    }

Error should probably be a regexp.

🔗 zboto Link

See #43 (comment)

derive_child_key could have a an extra argument to take a password and decrypt the mnemonic seed.

• extended test cases. Include external test vectors.
• test error handling

Maybe we could also add those tests cases :
https://github.com/ChainSafe/forest/blob/master/tests/cbor/unsigned_message_vectors.json

Just to be sure.

This should be aligned with Examples in #10

• adjust to new API
• setup vuepress
• document WASM API
• add comments to rust code (#81)

send_sign(transaction, private_key) -> txhash

It should raise an error if transaction is testnet but node is Mainnet and vice versa.

Fail to parse this transaction :

885501fd1d0f4dfcd7e99afcb99a8326b7dc459d32c62855015d77a86f78f72f2f71edc37ce67cb344417ea1520242000140400040'

By accident I have passed an extra caracter "`" and it panicked instead of sending an error.

log

The application panicked (crashed).
Message:  called `Result::unwrap()` on an `Err` value: InvalidLength
Location: src/libcore/result.rs:1165

Backtrace omitted. Run with RUST_BACKTRACE=1 environment variable to display it.
Run with RUST_BACKTRACE=full to include source snippets.

As we write examples, we can use this issue to also improve the API so the service is more intuitive.

The following testcase is failing when parsing :

    {
        "description": "Empty value",
        "encoded_tx": "iFUB0VAFBOTRrD6JrIkaRQJYb6vZtBdVAbiCYZ1GVY89njFtEbSNzyETJwJqAUEAQwAJxEMAYagAQA==",
        "valid": false,
        "testnet": false,
        "not_implemented": true,
        "message": {
            "to": "f12fiakbhe2gwd5cnmrenekasyn6v5tnaxaqizq6a",
            "from": "f1xcbgdhkgkwht3hrrnui3jdopeejsoatkzmoltqy",
            "nonce": 1,
            "value": "",
            "gas_price": "2500",
            "gas_limit": "25000",
            "method": 0
        },
        "encoded_tx_hex": "885501d1500504e4d1ac3e89ac891a4502586fabd9b4175501b882619d46558f3d9e316d11b48dcf211327026a01430009c4430061a80040"
    }

However the value seems to be optional :
https://chainsafe.github.io/forest/forest_message/struct.UnsignedMessage.html

My guess is that it should not fail.

The js integration tests for jsonrpc:

• get_nonce
• get_status

are disabled due to "Service Request Error"s that needs to be analysed.

The following test case fails :

    {
        "description": "TODO invalid test case ",
        "encoded_tx": "iEBAAEIAAEIAAEIAAABA",
        "valid": false,
        "testnet": false,
        "message": {
            "to": "",
            "from": "",
            "nonce": 0,
            "value": "0",
            "gas_price": "0",
            "gas_limit": "0",
            "method": 0
        },
        "encoded_tx_hex": "884040004200004200004200000040"
    }

I suspect that forest doesn't check that the length is not 0 and try to get the first byte here :
https://github.com/ChainSafe/forest/blob/d1194bdd942fcd9856376f1cb486739d9631d59b/vm/address/src/lib.rs#L222

Once StateGetReceipt is working we should maybe switch ChainGetMessage for this one. The current method return an error if not yet validated and only once we have a result we know it is validated. It is not optimal.

See #63 (comment)

Connect to Lotus compatible services and relay a signed transaction

• compile as WASM
• early JS example test
• early browser example

• Initial Lotus Node interaction
• Basic JSON RPC interface for signing library

Connect to Lotus compatible services and determine network (mainnet/testnet)

When using the wasm library to derive an address and private key and sign a message, the lotus jsonrpc sends back a "signature does not match" error.

We ran into this same issue with the Ledger once, here's the relevant conversation/fix:

usually people normally deal with compressed public keys (33 bytes)
[7:45 AM]
the are completely equivalent... any secp256k1 library will take one or the other without problem, etc. etc..
[7:45 AM]
the thing is.. addresses hash the pubkey... so then.. it is not the same if you use one or the other
[7:45 AM]
and for the same pubkey/privkey pairs, there were 2 addresses
[7:46 AM]
depending on which format is used (compressed/uncompressed)
[7:46 AM]
this can actually be a serious issue
[7:47 AM]
we have to use uncompressed everywhere or things will fail

This only fails when running inside Docker in CI. The tests pass locally

driver status: signal: 9                          
driver stdout:
    Starting ChromeDriver 2.46.628388 (4a34a70827ac54148e092aafb70504c4ea7ae926) on port 39291
    Only local connections are allowed.
    Please protect ports used by ChromeDriver and related test frameworks to prevent access by malicious code.

driver stderr:
    [1583857375.960][SEVERE]: bind() failed: Cannot assign requested address (99)

• fix npm publish
• publish rust crate / docs
• publish vuepress docs

It should return some average (or other reference value or stat) for gas requirements in the network

It requires support in Lotus

• Library
• Service
• CircleCI

Connect to a Lotus compatible service and retrieve tx status

• Use key_derive for the example.
• Add a small section in the documentation
• Adjust circleCI configuration to confirm
  This very likely depends on the Obj-C and Java examples

The recovery id and signatures need to be adjusted

https://github.com/Zondax/filecoin-rs/pull/29/files#r379428496

This will have an effect on tests too.

This requires ChainSafe/forest#233 to be merged first

If I am not mistaken we have the same issue with verify_signature than with recover_key.

We should also have a flag in order to specify the network when matching the recovered address from the signature and address extracted from the tx.

    // Compare recovered public key with the public key from the transaction
    if tx_from != from.to_string() {
        return Ok(false);
    }

Connect to Lotus compatible service and request nonces.

The Lotus jsonrpc expects a base64 encoded signed message, so this will make things easier for developers.

Transaction parse support should work for both signed and unsigned types. The function should accept CBOR hexstrings for both cases and detect automatically the correct type.

Remarks
key_derive only works when given a mnemonic. However the chances is that exchanges have a seed and not the mnemonic because mnemonic are mostly used for backup. Going from seed to mnemonic is not possible.

Proposition
We should support key_derive_from_seed(seed, path).

The signing service will rely on a connection to a Lotus node to:

• Request Nonce values for specific accounts
• Determine network (mainnet / testnet)
• Relay signed transactions to the network

Basic CBOR serialization/deserialization for Messages.
Demonstrate feasibility, etc.