It has left as TODO in code chain/x/zoracle/handler.go

• Check RequestID is existed
• Still in report period

prefixes is rather confusing, and is not even prefix. It's actually the combination of whether a proof is going on the left or right direction and a variable length data for a merkle internal node that is not relevant to Merkle proof (such as subtree version / subtree size / etc). Additionally, it's a uint256[] even though it has nothing to do with integers!

So, let's remove prefixes and introduce two new things:

• uint256 mask: This is a uint256 bitmask that encoded Merkle proof direction, kinda similar to Sparse Merkle Tree
• bytes[] extraInternalNodeData: Using, ABIEncoderV2, we can just directly accept bytes array. If it proves to be inefficient, we can always go back to the old approach, but I doubt it.

Introduce the inflation of BANDs. Adding minting features that will inflate BANDs to blockchain validators for every block produced, using the same parameters as the Cosmos chain.

Also let's merge UintLib with BytesLib since it only has function that is pretty much related to bytes.

• Merge UintLib with BytesLib
• Add comments / doc
• Add unit tests

Make it compatible with #78. It uses codeHash instead of code

What to do

• Explain how to run docker correctly
• Explain how to upgrade code and run with new upgraded images
• Explain how to restart chain to the genesis state

Research and build a POC version of Owasm runtime that terminate upon reaching certain gas limit. It is still pretty much open ended, but this should be a good starting place: https://github.com/wasmerio/wasmer/blob/master/lib/middleware-common/src/metering.rs.

Deliverables:

• Understand and present a possible way to do gas metering to prevent an infinite loop stops the network forever.
• Build some hacky POC that shows there's a way to do it on D3N.

Let's make the prefix 0xff following by Request ID, CodeHash, and Parameters.

Currently a compiled Wasm code needs to be sent with a data request transaction, causing a transaction to be huge. This is silly if the same source code is sending over and over. This epic is about creating messages and handlers to add code storage functionality.

The value actually consists of multiple things, including code hash, valid block number, actual data value, etc. Let's make smart contract on Ethereum able to parse the information.

We all know it supports getting proof, checking status, etc. But what exactly is the spec?

Currently it re-defines some data types that should just have been imported from Tendermint. Let's do that to reduce the amount of code we need to maintain. Note that this means we need to use the same mechanism to encode/decode data to JSON (most likely involved amino/codec).

We updated the way an array can be encoded by using just one 64 bit integer (top 32 encoding the size, and bottom 32 encoding the location of data). Let's update owasm code base to work like that.

D3N chain code uses docker for deployment. It would be good if a docker image for running D3N node is building automatically for every code update.

What to do before start

• Create the account on the Docker hub.
• Ask @evilpeach for Bandx repo's invitation.

Setup CI to run tests for every push that affects bridge/evm directory.

Currently the address prefix is cosmos. We should change it to band.

• Change prefix to band, including prefix of user address, validator address, etc
• Update and verify that docker related scripts are still working

Event subscriber from tendermint stop subscribe after listen 4 reports in one block

How to produce?
Run chain with 4 validators when request has been executed. All 4 validators send report to chain in the same block, but tendermint server cannot handle report event correctly. (Internal buffer is full with capacity = 1)

Possible root cause
After experiment error come from https://github.com/tendermint/tendermint/blob/master/libs/pubsub/pubsub.go in send function. Code cannot push new event to channel because it's full. Consumer is https://github.com/tendermint/tendermint/blob/master/rpc/core/events.go that consume data after new event push make pubsub return error and try to cancel subscription.

• But ws client have code to resub after got error but code doesn't work out as expect. It return error told that already subscribe

Way to solve

• Make sure consumer consume event fast enough (?) for new event
• Increase buffer size of buffer
• Make resubscription work as code expected

v is missing 😨.

Deliverables:

• Presentation on what research has been done
• Present potential solutions and their tradeoffs
• Plan on how to proceed with on-chain address recovery

Potential Solutions

• Try two different vs on-chain
• Compute for v off-chain
• Something else???

Some pointers:

• https://crypto.stackexchange.com/questions/18105/how-does-recovering-the-public-key-from-an-ecdsa-signature-work
• https://bitcoin.stackexchange.com/questions/38351/ecdsa-v-r-s-what-is-v

We decided to go with the module name from oracle to zoracle to simplify the steps required to perform multistore proof checking. Now that we did this, let's change every occurrence of oracle name to zoracle to avoid confusion down the line.

• Presentation materials (Google slide of what D3N is)
• Demo script
• Rehearse with the tech team

Currently the coin address is stake. We want to change it to BAND to celebrate the existence of Band token on its own sovereign chain.

• Update necessary code to change coin unit to BAND
• Verify and update that the genesis file and its generating script still works

• should test with 4 validators

Code storage keeper and handler allows the blockchain to process code storage messages. D3N should handle MsgStoreCode by keeping the code in a long term storage, using code hash as lookup key. MsgDeleteCode should remove the code from the storage. As simple as that!

• Implement keeper(s)
• Implement handler(s)
• Add tests

In that case, the task should just return whatever was already printed to stdout.

Instead of hardcoding the whole config.toml for seed/persistent peers. We can pass them directly as the command line arguments when running bandd start. That way, we have one less (quite big) file to maintain!

The messages allow user to store and delete code from the blockchain long term storage. The code can be referred later with code hash.

• Implement the messages data structure to zoracle module
• Add necessary test cases

To prevent potential exploit directly to the host, all commands should be run inside of a one-time-purpose docker instance. This also helps with having one consistent docker runtime for all data providers to support similar programs with similar versions / environments.

It was hardcoded just to allow test to run. Update the unit tests and remove the TODO line.

And only allow valid app hashes that have been signed by enough validators to be stored on the contract.

After code store messages are complete. MsgRequest should just accept code hash.

• Edit MsgRequest to take code hash instead of full code
• Change handler of MsgRequest to code from storage and throw error if code does not exist