wavesplatform / gowaves Goto Github PK

Аbstract
Allow the removal of data entries in account's state.

Specification

The 4th version of DataTransaction supports keys with empty data. If user puts a key without data into DataTransaction this keys should be removed from account's state along with existing data.

• It is possible to add, update and remove entries in one DataTransaction if keys a different
• Data associated with removed key should be remove from state
• Previously removed keys can be used again with new data
• Removing nonexistent key is no-op
• User can add up to 100 keys for removal in one DataTransaction

Specification
Reduce reissue transaction fee to enable cheap reissue of utility tokens.

Аbstract

Is your feature request related to a problem? Please describe.

Yes. wmd v0.3.0 cann't synchronize database from NODE REST API on local node,
and need to raise gRPC server there. What if I use old version of the node???
Also, synchronization is stopped at blocks 1610029 - 1610030.
See the details in this issue: #285
So, need to fix it, in the next versions of wmd.exe

Motivation and Purposes

A clear and concise description of what the problem is. Ex. I'm always frustrated when [I cann't downloading candles and trading history for all trading pairs].

** Specification**

A clear and concise description of what you want to happen.
Describe alternatives you've considered

I want to load candles and orders history for all trading pairs, to display this data in waves-lite client.
I want to do this from my local node, not from remote node, which can go offline at any time.
I want to do this up to end block, without see any errors at blocks 1610029 - 1610030.

Backwards Compatibility

Can your proposition affect any existing features?

No. Just fix this WMD.exe.

Examples and Implementation

Examples of implementation in other projects?

https://marketdata.wavesplatform.com this is working fine, but this is remote server.

Аbstract
Node currently connects to unlimited number of peers.

Motivation and Purposes
Even limited number of connections is enough for node to function securely.

Specification
New config option that specifies the limit of connections should be introduced.

Backwards Compatibility
Backward compatible.

Аbstract
The interpretation of RIDE scripts is slow. The idea is to transpile scripts those already in blockchain into a native Go functions and use them while importing blockchain or while validation of all scripts known at the moment of release.

Motivation and Purposes
To speedup the import and validation of blocks, to reduce the memory footprint of the node.

Specification

1. Transpiler
   Implement the transpiler as a command line utility that will extract all scripts that in given blockchain file and generate Go source code for every script.
2. Node with built-in scripts
   Include the generated functions in separate package in gowaves node. Add the index to lookup for the native function for a script. If there is a native function for a script in blockchain use it to validate transactions, if not use the default interpretation technic.

Backwards Compatibility
In case of impossibility to transpile a script the existing interpretation will be used.

Specification
Implement new RIDE V4 function to check validity of Merkle root:
createMerkleRoot(merkleProofs: List[Bytes], valueBytes: ByteVector, index: Int): ByteVector

Specification

Implement RIDE function SponsorFee(assetId: ByteVector, minSponsoredAssetFee: Int|Unit) to produce a Sponsorship action as a result of script invocation. The effect of the action is the same as for Sponsorship transaction.

Specification

Minimal fee for Sponsorship transactions should be reduced from 1 Waves to 0.001 Waves.

Аbstract
A gowaves node knows IP addresses of seed nodes (initial nodes to connect to) from the built-in configuration. Also the initial nodes could be provided by the command line parameter -peers. It seems better to replace or the built-in seed peers with the DNS record lookup.

Specification
Built-in configuration should support domain names along with seed nodes IP addresses. Those domain names should be resolved to underlying IP addresses and those addresses should be treated as usual seed nodes IP addresses.
The argument of -peers command line parameter should be parsed the same way as built-in configuration.

Backwards Compatibility
Configuration and -peers command line parameter should support IP addresses passing for backward compatibility.

Examples and Implementation
Bitcoin operates the same way.
https://github.com/btcsuite/btcd/blob/535f25593d47297f2c7f27fac7725c3b9b05727d/connmgr/seed.go#L33

Specification

In RIDE v4 function wavesBalance(Address|Alias): BalanceDetails should return BalanceDetails structure. BalanceDetails structure consists of 4 fields:

• regular - amount of Waves
• available - amount of Waves that can be spent (except leased Waves)
• effective - amount of Waves including leased Waves
• generating - minimal amount of effective balance during 1000 last blocks

Аbstract
New transaction to update description of existing asset.

Motivation and Purposes
To allow users to change name and description of existing asset.

Specification
Transaction ID: 17.
Transaction Name: UpdateAssetInfo.
Protobuf schema: https://github.com/wavesplatform/protobuf-schemas/blob/master/proto/waves/transaction.proto.

Limits:

• Token Name: 4 to 16 bytes.
• Token Description: up to 1000 bytes.
• Token description could be changed only after 100000 blocks passed since last description change.

Describe the bug
There is no flag to disable gRPC server.

To Reproduce
Steps to reproduce the behavior:

1. Start the node:

./node -state-path /Users/alexeykiselev/gowaves/mainnet

2. If there is other node with gRPC API running the error message should appear:

ERROR    grpcServer.Run(): net.Listen: listen tcp 127.0.0.1:7475: bind: address already in use

Expected behaviour
The gRPC server should not start without flag.

How should I receive SecretKey & PublicKey, if i have a seed? I'm using the following function:
sk, pk := crypto.GenerateKeyPair([]byte("gospel rule red grit faculty clog happy client concert final weird plastic"))

But sk and pk are not as expected. How can I receive correct sk and pk in this way?

Motivation and Purposes

Now the network scheme from settings is used everywhere. In order to support interoperability with side-chains we have to restore scheme from binary transaction representation.

Аbstract
Add MerkleRootHash of block's transactions.

Motivation and Purposes
Block generator signs only block header which in turn contains a root hash of Merkle tree of all block's transactions. This change allows to verify block without downloading all block's transactions and will be used to develop sidechains.

Specification

The Merkle tree should be build as follows:

1. Calculate the digests of all block's transactions: hash(L1), hash(L2), hash(L3) and so on.
2. Calculate the digest of pairs of transaction's digests. For example, hash(hash(L1) + hash(L2)). If block contains odd number of transactions, the last transaction digest is used twice to calculate the pair's digest: hash (hash(L3) + hash(L3)).
3. Repeat the step 2 until only one digest left, this is the root hash.
4. Save the root hash in block's header.

hash (hash (hash(L1) + hash(L2)) + hash (hash(L3) + hash(L3))) = Root Hash

Notes:

1. Transaction's digest is calculated from whole transaction including signature.
2. Blake2b256 hash function should be used to calculate digests in Merkle tree.

Specification

Block's TransactionRoot field should be accessible from RIDE scripts.

Аbstract
Now it's validated that the first order in an exchange transaction have to be a BUY order and the second is SELL. Protobuf version of Exchange transactions should support any order of orders in transaction.

gRPC API has many uses, but the most important is to provide API compatibility with Scala integration tests infrastructure.
In future this will help us to fix problems detected by these integration tests.

RPCs are described in pkg/grpc/proto/*.proto files.
Generated code is is pkg/grpc. Server RPCs implementation is in pkg/grpc/server.
RPCs call node state to retrieve required information (refer pkg/state/api.go).

github.com/wavesplatform/gowaves/pkg/crypto/internal/groth16/bls12381
....\github.com\wavesplatform\gowaves\pkg\crypto\internal\groth16\bls12381\verifier.go:16:94: cannot use inputs[i] (type *big.Int) as type *bls123
81.Fr in argument to PointG1.MulScalar

Specification

New user function to create Issue should be implemented in addition to existing Issue constructor. This new simplified function does not have parameters compiledScript and nonce. They a filled with default values Unit and 0 accordingly.

Issue(name: String, description: String, quantity: Int, decimals: Int, isReissuable: Boolean).

New function ID should be introduced:

• 1090 for simplified function
• 1091 for detailed constructor

ID Issue for constructor should not be used.

Specification

Function assetInfo(ByteVector): Аsset|Unit should return name and description fields of an asset.

Аbstract
In order to simplify support and integration use Protobuf as internal data serialisation me framework.

Specification

Use protobuf schemas from protobuf-schemas project to implement BlockV5 and 4th versions of all transactions.

Backwards Compatibility
For backward compatibility implement a new network messages to request and send BlockV5.

• BlockV5
• TransactionsV4
• Network messages for BlockV5

Аbstract
Currently the block signature is used as a block ID to reference to. It should be replaced with hash digest of block's header.

** Specification**

• Replace block signature with hash digest of block's header
• Add new network messages to request and receive blocks IDs

Specification
Groth16Verify - a function which can receive {verification key, proof, inputs} as a compressed data and check zk-SNARK by groth16 protocol on the bn254 (bn256) and bls12-381 curves.

Examples and Implementation
Rust implementation:
https://github.com/wavesplatform/zwaves/blob/master/zwaves_jni/src/lib.rs#L39

Specification

Data limits:

• String and ByteVector constructors - DataEntry value limit (32767 bytes)
• String and ByteVector concatenation - DataEntry value limit (32767 bytes)
• DataEntry key size - 400 bytes (as for protobuf Data transaction, instead of current 100 bytes)
• max available ByteVector - (106 + 165890) = 165996 bytes (body bytes of protobuf Data transaction)

Functions:

• sigVerify message - no limit (indirectly Data Transaction protobuf max size)
• rsaVerify message - no limit (indirectly Data Transaction protobuf max size)

Naming limits:

• user function and variable names length - 255 bytes (as for Callable functions)

Аbstract
To simplify the usage of node's gRPC API enable built-in gRPC reflection server following the instructions.

Motivation and Purposes
For now, the node's gRPC API could be discovered only by downloading and embedding Protobuf schemes in a client application.

Examples and implementations
The examples are available at known implementations page.

Write section about how to setup gowaves node for mining. How to create and use wallet file.

Аbstract

For more information see WEP9.

Transactions with failed scripts should be stored in blockchain. All transactions with valid sender signature should be stored on blockchain even if it's script execution leads to failure. Fee for storing such transactions should be paid by sender.

Motivation and Purposes

Users of Waves blockchain can do non valid transactions without paying for it. Script execution is resource consuming operation, so transactions with failed scripts should be paid.

Specification

Transaction application should work as follows:

1. Transaction's timestamp validation
2. Transaction's version check
3. Check sender's balance for available amount of spend assets
4. Check sender's balance for available amount to pay fees
5. Check transaction's proofs, execute verifying script
6. Build state modifications for transaction
   6.1. For Invoke Transaction execute DApp script
   6.2. Build all resulting Invoke actions
   6.3. Execute Smart Assets scripts for all Invoke actions
   6.4. Check sender's balance for availability of additional funds to pay actions' fees
   6.5. Execute Smart Assets scripts for payments
   6.6. Execute Smart Assets scripts for actions
7. Apply transaction

Changes to existing procedure:

1. Check sender's balance before scripts execution
2. Execute Smart Assets scripts after execution fo account script
3. Execute DApp script before execution of payment's script
4. Check sender's balance for availability of funds to pay additional fees for Invoke actions before execution of those actions scripts

Only Invoke and Exchange transactions should be stored if failed.

Backwards Compatibility

The ability to pay fee for DApp execution with funds received in attached payment will be broken.

c,err:=NewClient()
	require.NoError(t, err)
	block,_,err:=c.Blocks.Last(context.Background())
	require.NoError(t, err)

Error: Received unexpected
failed to decode Attachment from JSON Value: zero length string

Specification
Implement new function transferTransactionFromProtoBytes(b: ByteVector): TransferTransaction|Unit. That should parse Protobuf binary representation of Transfer transaction to its object representation.

Аbstract

Is your feature request related to a problem? Please describe.

Yes. Blockchain too large.

Motivation and Purposes

A clear and concise description of what the problem is. Ex. I'm always frustrated when [I need to download large files and lost the limited traffic].

Specification

A clear and concise description of what you want to happen. Describe alternatives you've considered

I just don't see the option to import the existing blockchain, or read the data inside the blocks from the already runned node. Why I need to download the binary file, to import this, when I already have synchronized blockchain???

Backwards Compatibility

Can your proposition affect any existing features?

I think, WMD can loading the blocks from the runned node, by requests on the NODE REST API,
or read the .ldb-files in the existing directory of the node, without downloading and store again the binary-file, with full blockchain (33GB).

Examples and Implementation

Examples of implementation in other projects?

https://github.com/PyWaves/WavesDataFeed make the requests on the runned node, to parse data inside the blocks, which are existing there.

Specification
FairPoS implementation limits minimal block interval to 5 seconds, this parameter must be increased to 15 seconds.

Specification

For OrderV4 the price should be calculated as follows:

spendAmount = amountOrderV4 * priceOrderV4 * 10^(priceAssetDecimals - amountAssetDecimals - 8)

Where,

• spendAmount - amount of assets (in normalised form) that user buys
• amountOrderV4 - amount of assets (in normalised form) that user sells
• priceOrderV4 - amount of assets (in normalised form) that shows ratio of assets in order's pair
• priceAssetDecimals - number of decimals of asset from price_asset_id field
• amountAssetDecimals - number of decimal of asset of amount_asset_id field

For Protobuf:

ExchangeTransactionData.amount() * ExchangeTransactionData.price() * 10^(ExchangeTransactionData.Order.AssetPair.price_asset_id().decimals() - ExchangeTransactionData.Order.AssetPair.amount_asset_id().decimals() - 8)

Specification

Implement those functions:

indexOf(list: List[T], element: T): Int|Unit

lastIndexOf(list: List[T], element: T): Int|Unit

containsElement(list: List[T], element: T): Boolean

min(list: List[Int]): Int

max(list: List[Int]): Int

Describe the bug
Executing Node binary on test- or stagenet causes an error.

To Reproduce
Steps to reproduce the behavior:

1. Download 0.3.0 "Node Alpha"
2. ./node -blockchain-type testnet
3. See error

Error Message
ERROR failed to open genesis file: open /Users/alexeykiselev/go/src/github.com/wavesplatform/gowaves/pkg/state/genesis/stagenet.json: no such file or directory

Аbstract

Implement the secure, detachable wallet that will be used by node during new blocks generation.

Motivation and Purposes

To enable block generation on node we need a built-in wallet that holds private keys that can be used by miner for block generation. The wallet should have a storage in form of encrypted file.

Specification

• Wallet's file format is JSON encrypted with AES.
• Key generation algorithm like Argon2 should be used to create AES encryption key from passphrase.
• Node should have an API method to Open/Decrypt wallet with a passphrase. This API method should be accessible only by local endpoint.
• Node should provide an API method to Close/Detach a wallet that should unload and wipe out from memory the containing private keys.
• Wallet should be able to store multiple accounts derived from different seed phrases/account seed.
• User should be able to created wallet's file using special utility that should accept/generate seed phrases, account seeds or private keys in different formats.
• Private keys inside a walled should be identified by its account.

Examples and Implementation
Ergo has a detachable wallet that could be created, opened and closed using it's API.

Аbstract
In order to reduce complexity of some heavy RIDE functions make the size limited versions of such functions with various complexity depending on size of arguments.

Specification
Introduce the limited versions of following functions:

Specification
Implement features of RIDE V4.

• Add Issue, Reissue and Burn actions as results to InvokeScript transaction
• Allow attachment of 2 payments to InvokeScript transaction
• Disable invoke with attached Payment or Transfer to itself
• Replace DataEntry with BooleanEntry/StringEntry/BinaryEnrty/IntegerEntry
• Remove ScriptResult/WriteSet/TransferSet
• Check RIDE V4 activation
• Add VRF to RIDE's BlockInfo
• Implement new functions of RIDE V4:
  • List functions
  • Contains function for strings
  • valueOrElse() function
  • zSNARK verify
  • calculateAssetId

Describe the bug
Sometimes, the current time is set to a moment in very far future. Possibly NTP synchronisation produces the value that overflows uint64.
The issue prevents from synchronisation of a node with the network.

StateSync: Error: block timestamp validation failed: block from future error: block's timestamp is too far in the future, current timestamp 18446742403992908309, received 1584064795750, maxTimeDrift 100, delta 3253781439057

In this example the current time was set to Sunday, 21 July 2554 23:06:43.992.

Specification

Implement function ecrecover(msg: ByteVector, signature: ByteVector): ByteVector for verification of ECDSA signatures.

one pair keys generated via func GenerateKeyPair
sk,pk
YoLY4iripseWvtMt29sc89oJnjxzodDgQ9REmEPFHkK 3qTkgmBYFjdSEtib9C4b3yHiEexyJ59A5ZVjSvXsg569

when I started with this 3qTkgmBYFjdSEtib9C4b3yHiEexyJ59A5ZVjSvXsg569
then

java.lang.Exception: InvalidAddress(Wrong address string length: max=36, actual: 44)

they are really different with recipient of devnet.conf

3FgScYB6MNdnN8m4xXddQe1Bjkwmd3U7YtM
3qTkgmBYFjdSEtib9C4b3yHiEexyJ59A5ZVjSvXsg569 (generated)

anybody could tell me why?

Аbstract
Add support for VRF generation signature as described in WEP8.

• Implement VRF
• Implement new generation signature
• Attach activation of new VRF generation signature to BlockV5 feature activation

Аbstract
Node should have an ability to vote for features and block reward while generating a new block.

Motivation and Purposes
Now miner doesn't support voting at all, so gowaves nodes will be mute during the voting periods.

Specification
We have to add a command line parameters to give node owner the ability to select desired features to support and set the desired block reward. Later on the given parameters should be passed to miner and miner should put them in the block.
Node should not allow to vote for not implemented or already approved feature.

Specification

Function assetBalance(addressOrAlias: Address|Alias, assetId: ByteVector): Int should fail in case of Unit is passed as assetId.

Аbstract
Should use the link and rewrite the existing build using dh tools with correctly scripts and checks.

Motivation and Purposes
Packages will be correctly removed, there will be no conflicts between mainnet and testnet

Аbstract
Now in tests used a mixture of MainNet and TestNet schemes. Better to stick to TestNet. Some tests that checks real objects from MainNet should use scheme accordingly.

Motivation and Purposes
Simplifying the decision which scheme to use while testing.

Describe the bug
Unable to get extra fee on scripted account because field name that contains it's value is incorrect.
Field has JSON name extra_fee should be extraFee.

Аbstract
Now WMD requests blocks one-by-one using waves.node.grpc.BlocksApi/GetBlock method, in cases then it's clear that WMD have to request range of blocks better use waves.node.grpc.BlocksApi/GetBlockRange gRPC API method.

Motivation and Purposes
This part is legacy of old HTTP API, we have to use all advantages of gRPC API.

Аbstract

With version 4 of RIDE assets can be issued, reissued or burnt by dApp. WMD needs full support of this new functionality.

Specification
Information about assets should be gathered not only by processing transactions, but also by processing script results of invoke transactions. We have to add support of Issue transaction and parsing of it results for assets creation and modification.

** Specification**
Node's gRPC API should be updated to version 1.2.4 of waves/protobuf-schemas.

• Add transaction to InvokeScriptResult
• Add ApplicationStatus
• Add total block ID to MicroBlockMessage