In the Token wrapper contract, we need to do the following:

• [ ] Identify the normal units of the psp22 token
• [ ] Integration test for getting amount to wrap

The computed hash_data in the contract seems to be wrong, different from the one i got from the ProvingManagerSetupInput which is in the webb.js repo

For the Invalid hash data being computed by the contract, I started investigating that, and I noticed the following for now:

a. I noticed the way we encode the fee bytes and ext_amount bytes is wrong, we are using to_le_bytes() encoding which gives a different output

b. I also noticed that the encrypted_output in ExtData is a fixed size of 32 bytes, it should actually be a vec<u8> as the encrypted_ouput can be more than 32 bytes.

@drewstone advise i reverse the bytes for the fee and ext_amt generated in the contract.

So, concerning the signature bridge, i have a concern. Currently in ink!, you can only make cross contract call by first instantiating the external contract/s via a reference. There is no way ideally to make a cross contract call via just the contract address as it is being done in solidity(like here and here ) and cosmwasm(like here and here). Leaves me wondering how best to handle the calls to different contract handlers in the signature bridge?

Write integration test for the treasury contract to do the following:

• [x] set handler
• [x] rescue tokens natively
• [x] rescue tokens with token address(PSP22)

Part of our protocol is the Token Wrapper Handler implementation, which is developed as a contract in protocol-cosmwasm and protocol-solidity. The Token Wrapper Handler is also implemented as a Pallet in protocol-substrate.

closes #50

Task Description

• [x] Implemented Signature Bridge

• [x] Make use of low level cross contract calls to handler contracts

• [x] Ink crates version bump across contracts and lib

• [x] Test for Admin Set Resource for Token wrapper handler in signature bridge

• [x] Test for Set fee proposal for Token wrapper handler in signature bridge

We have implemented the Governed Token Wrapper Contract, Now we need to integrate the contract into the VAnchor for wrapping and transferring of PSP22 Tokens.

We also need to Implement PSP22 Token transfer in the VAnchor contract too.

Overview

The LinkableTree contract extends the MerkleTreePoseidon contract with a graph-like interface for linking to other LinkableTrees. Links between these trees are represented as directed edges (since updates occur on one contract per transaction). The edge data is maintained as a record of the:

• Chain id that the edge points to
• Latest merkle root of the MerkleTreePoseidon contract being linked
• Latest leaf insertion index (used as a nonce) of the linked merkle tree.

Relevant links

• [ ] LinkableTree.sol
• [ ] protocol-cosmwasm

Overview

To build the VAnchor, we should start by implementing all necessary storage functions for it. Since Ink is a smart contract platform, we can reference the solidity implementation and the cosmwasm implementation:

• Solidity
• CosmWasm

Tasks (non-exhaustive)

• Support for a merkle tree with methods for insertion
• Support for linkable trees with methods for adding/updating edges
• Support for 2 verifiers (for 2-2 and 16-2 txes) with methods for verifying proofs

Overview

We should ensure that our ink! contracts follow the token standard that is outlined in psp-22.

You can also see OpenBrush psp-22 example usage for additional details on implementation.

Write test to cover the following for treasury Handler contract:

• [x] Migrate Bridge
• [x] Set Resource
• [x] Execute Proposal for setting treasury handler
• [x] Execute proposal for rescuing tokens

Closes https://github.com/webb-tools/protocol-ink/issues/40

Task list

• [x] Introduce a PSP22 token_address optional property in mixer storage.
• [x] Introduce a non-payable contract function for depositing PSP22 tokens into the mixer.
• [x] Add integration test for testing PSP22 token deposit and withdrawal in the mixer.

Dependent on the merge of https://github.com/webb-tools/substrate-contracts-node/pull/5

closes #73 #76

Task Description

• [x] Implement computation of ext_data_hash using ethabi
• [x] Transact Deposit test
• [ ] Transact Withdrawal test
• [ ] Transact Deposit Wrap Native test
• [ ] Transact Deposit Wrap Psp22
• [ ] Transact Withdraw Unwrap

Overview

The VAnchor is currently not tested well enough. We need to add tests for deposit, withdraw and negative tests for both psp22 and native assets.

Task Checklist

• [ ] Add tests for deposit with psp22
• [ ] Add tests for withdraw with psp22
• [ ] Add tests for wrapping native asset
• [ ] Add negative tests

Relevant Links

Overview

We need to add additional negative tests for each contract handler.

Task Checklist

• [ ] Negative tests for anchorHandler
• [ ] Negative tests for treasuryHandler
• [ ] Negative tests for tokenWrapperHandler

Relevant Links

When I try to implement event emission in the VAnchor Contract, I get this error:

error[E0284]: type annotations needed
   --> contracts/vanchor/lib.rs:354:24
    |
354 |             self.env().emit_event(TransactDeposit {
    |                        ^^^^^^^^^^ cannot infer type for type parameter `C` declared on the trait `EmitEvent`
    |
    = note: cannot satisfy `<_ as ink_lang::reflect::ContractEventBase>::Type == _`

This is actually due to the fact that the token_wrapper contract emits event too and is being called in the VAnchor contract which is also trying to emit events.

This is a cross-contract bug that has been raised in Substrate stack exchange

The issue is already opened in ink! here The PR to fix this issue is being tracked here

We are following the PSP22 Token standard which is similar to the ERC-20. We need to ensure that the contract is able to do transfer both in native tokens and psp22 standard token.

A todo was put up here