I have made some progress with the majority of functions (Thank you @Aimeedeer as I used your work as a stepping stone). I am left with the create_pair function and possibly adding error handling

There's not much to look at yet, but I've sketched out the main things I think a uniswap UI needs:

• the menu with items for "swap" and "pools"
• a system status widget for connecting the wallet, showing the address, etc
• a swap component
• a pool list component
• a status message overlay

I decided to try tailwindcss for this and so far it's making it fairly easy to get a layout going.

It can be run with npm run dev once the dependencies are installed (cd www && npm install).

Some notable things I did

• changed Vec<u32> to Vec<u8> to represent bytes types
• removed all the todos about u256 - there are so many we're just going to have to take another pass over these once we better understand the types in ink.
• changed the crate type to rlib since this is just a library - it is not compiled to a wasm contract
• added tuple return types where appropriate. some of these might want to be named types later on

cc @kris524

Uniswap uses bytes32 in a few places. This is an array of bytes up to 32 in length, not strictly 32 bytes. Do we need such a thing? Right now we are just using Vec<u8>.

The solidity contract uses several types that we are not:

• uint - a 256-bit integer
• uint112 - a 112-bit integer?

Right now we are just using u64 for these, but need to figure out the correct types.

This issue is for tracking and assigning major tasks. Feel free to edit.

We are going to try to translate uniswap v2 to Ink and run it on Astar (or other networks that support the Substrate wasm palett). This will involve

• Building Rust contracts in ink - Uniswap is well factored in a way we should be able to divide the work up
• Writing unit tests for those contracts
• Probably developing a Rust CLI to drive the contracts from the command line, for development, administration, and integration testing
• Creating a JavaScript module for driving the contracts from the web browser
• Creating a web app
• Creating final presentation materials

It probably won't involve Substrate hacking, though we can try to come with an excuse to make our own Substrate chain..

Some background links:

• Hackathon: https://polkadot-na.devpost.com/
• Hackathon guide: https://angelhack.notion.site/Polkadot-Hackathon-North-America-Edition-Participants-Guide-0f6d16e7db4849a9a4902241f0d4a5cf
• Ink: https://github.com/paritytech/ink
• Astar: https://docs.astar.network/
• Uniswap v2 core contracts: https://github.com/Uniswap/v2-core/tree/master/contracts
• Uniswap v2 periphery contracts: https://github.com/Uniswap/v2-periphery/tree/master/contracts/interfaces
  • It looks like the router contract may be the only thing relevant to a new implementation
  • We can worry about these later
• Uniswap tests: https://github.com/Uniswap/v2-core/tree/master/test
• Substrate RPC libraries for Rust:
  • https://github.com/paritytech/substrate-subxt
  • https://github.com/scs/substrate-api-client
• Polkadot tokens
  • https://github.com/w3f/PSPs/blob/master/PSPs/psp-22.md
  • https://github.com/paritytech/substrate-open-working-groups/blob/main/SOWG/1-polkadot-token-standard.md

Tasks:

• [x] Create skeleton repo. Top level cargo workspace with a 'components' directory to hold further crates. Perhaps start with one crate to hold the traits (uniswap's interfaces) called swap_traits, and we can go from there once we understand more. (@kris524)
• [x] Outline the uniswap traits in swap_traits, figuring out equivalent ink idioms for solidity idioms.
  • [x] IUniswapV2Callee (@kris524)
  • [x] IUniswapV2ERC20 (@domroselli)
  • [x] IUniswapV2Factory (@kris524)
  • [x] IUniswapV2Pair (@kris524)
• [x] Figure out what the equivalent of the ERC20 interface is in Ink and how we need to integrate it.
• [ ] Implement the three uniswap contracts. These probably need to be their own crates but not sure.
  • [x] UniswapV2ERC20 (@Aimeedeer)
  • [ ] UniswapV2Factory (@kris524)
  • [ ] UniswapV2Pair (@kris524)
  • [ ] PSP22 (Fungible Token Standard for Polkadot) (@Aimeedeer)
• [ ] #20
• [ ] Create an integration test harness. Uniswap does this in typescript but I think we can do it in Rust. This will involve using a substrate RPC library to drive the contracts.
• [ ] Implement the existing uniswap tests from https://github.com/Uniswap/v2-core/tree/master/test
  • [ ] UniswapV2ERC20
  • [ ] UniswapV2Factory
  • [ ] UniswapV2Pair
• [ ] Create a web frontend (brson). https://github.com/kris524/Polkadot-Hackathon-North-America-Edition/issues/8