Tests should run on travis before PR merge

In iov-one/iov-core@da10566 we explicitly allow every account willing to spend transaction fees to claim or abort a swap. We should verify this is implemented and add 4 tests ensuring this property.

• Every account can Eth/claim
• Every account can Eth/abort
• Every account can Erc20/claim
• Every account can Erc20/abort

Builds on #2

With web3, you can connect to a contract via:
let contract = web3.eth.contract(PASTE ABI HERE!);

And set the bytecode once via:
contract.new({from.., gas..., data: "PASTE_HEX_BYTECODE_HERE"})

We should upload via iov-core/iov-etherum code.
At this stage we can use web3/truffle/etc tooling to validate the data is properly writen to the blockchain, by querying the address.

Acceptance Criteria

• Given ABI and Bytecode, and an account with some funds, upload contract to ganache
• Create a iov-ethereum specific UnsignedTransaction to represent this (CreateContractTransaction ?)
• Validate the contract can be viewed via web3 and the bytecode is properly stored.

When I use

await expect(Promise.resolve(2)).eventually.to.equal(3);

in tests, they pass for some reason.

• Apache-2 licence (copy from iov core)
• No external contributors
• Rewrite contract from scratch
• TDD?
• Focus on Ether only first
• Renaming
• Events in past tense
• Move state into struct
• Combine check and checkSecret
• Remove Pausable
• Linting
• Look into etheno [not necessary for now]
• Analysis scripts (slither, manticore, truffle-security)
• Truffle/ganache
• CI setup (especially for linting)

If we include amount and sender as well, we can watch logs and let the client show new swap offers without an extra query., similar to BNS:

  public swapOfferFromTx(confirmed: ConfirmedTransaction<SwapOfferTransaction>): OpenSwap {
    const transaction = confirmed.transaction;
    return {
      kind: SwapState.Open,
      data: {
        id: confirmed.result as SwapIdBytes,
        sender: identityToAddress(transaction.creator),
        recipient: transaction.recipient,
        hash: transaction.hash,
        amounts: transaction.amounts,
        timeout: transaction.timeout,
        memo: transaction.memo,
      },
    };
  }

but with watching logs instead of watching transactions

Depends on #14

We need a smart contract for atomic swaps that handles erc20 tokens, not just ether.

Something like https://github.com/iov-one/ethereum-smart-contracts/blob/master/contracts/AtomicSwapEther.sol but for erc20.

Should be easy enough with the other examples and the experience.

When adding custom contracts to the ethereum chain (or our test chain), we will need to compile some human-readable solidity into evm bytecode, so it can be uploaded.

truffle toolkit will compile and upload together. We should choose and document some tools we can use to compile into one file that we can upload separately.

Acceptance Criteria

• Add description of the tooling to a README in iov-ethereum package (we can also extend section on ganache)
• Copy a reference erc20 contract to a folder under scripts/ethereum for tests
• Add a script to scripts/ethereum to compile this contract and save the output in another directory
• Make sure to expose the ABI (method definitions) as well as the raw bytecode