Fenrir - 2020-12-18

Support for on-chain progression of app channels.

Added
- On-chain progression: The channel watcher is now interactive and informs the
  client when a channel has been registered on-chain. If the channel has a
  defined app logic with a valid state transition logic, clients can
  individually progress the app state on-chain according to the defined state
  transition logic by calling `ProgressBy` on the channel object.
- Settle with sub-channel disputes: Ledger channels can now be settled with
  funds locked in disputed sub-channels if the corresponding sub-channels have
  been registered and the disputes have been resolved on-chain.

Changed
- The channel watcher logic changed. The channel watcher now takes as input an
  event handler which gets notified about on-chain channel events. Before, the
  watcher automatically settled a channel in case of a dispute. Now, the watcher
  will automatically detect if an old state has been registered, refute with the
  most recent one, and notify the user. If the channel has a defined application
  logic, the user can further progress the channel on-chain. It is within the
  responsibility of the framework user to finally settle the channel and
  withdraw the funds.
- The channel settling logic changed. Before, a call to `Settle` on a channel
  object automatically registered the channel, concluded it, and withdrew the
  funds. Now, to accomodate on-chain progression functionality, the user must
  call `Register` independetly before being able to settle the channel.
  Afterwards, for app channels, the user has the opportunity to  progress the
  channel state on-chain by calling `ProgressBy`. Finally, the user can settle
  the channel by calling `Settle`.
- `ContractBackend.NewTransactor` now sets the context on `TransactOpts`.
  Furthermore, parameter `value` has been removed.

Fixed
- Persistence: Sub-channels are now persisted and restored properly.

European Ecstasy - 2020-11-05

ERC20 and Funding Agreement support and many test fixes.

Added:
- Funding agreement support: when proposing channels, the proposer can now
  optionally suggest to reallocate the funding responsibilities among the
  participants so that it differs from the initial channel allocation.
- ERC20 support.
- A context-aware `WaitGroup` implementation to `pkg/sync`.

Changed:
- The `eth/wallet/hd.Transactor` to use the correct `types.Signer` if the
  `Wallet` has a correct `SignHash` method.
- The Go version to 1.15.

Fixed:
- Many timeouts in tests that made slow CI pipelines fail.
- A bug in the Concurrent Tester.
- The `Client` role tests to not deadlock so easily.

v0.4 fix release

Check for NoApp in ethereum backend when converting apps into addresses.

Intermediate release to expose Ethereum Account on eth/wallet/hd.Account

Europa - 2020-10-17

The Sub-Channels release, enabling fully generalized state channels.

Added:
- Sub-Channels: run app-channels inside parent (ledger) channels.
- Special `NoApp` for channels without app. Skips force-execution phase in
  disputes.
- Optimized `Channel.SettleSecondary` settlement method for the responding
  settler during optimistic channel settlements. Avoids wasting gas by not
  sending unnecessary transactions.
- `ErrorGatherer` type to `pkg/errors` package for errors accumulation.
- Transactor abstraction to allow different wallet implementations for
  transaction sending in Ethereum backend.
- App registry so that multiple apps can be used in a single program instance.

Changed:
- `channel.Update` to accept a `channel.State` instead of `channel.ChannelUpdate`.
  This simplifies the usage.
- Contracts updated to handle sub-channels.
- Contracts now have distinct dispute and force-execution phases.
- Channel proposal protocol now uses shared nonce from all channel peers.

Fixed:
- Channel peers persistence in key-value persistence backend.

Intermediate release for perun-node development.

Changes and new features include:
- Update of contracts to Solitidy 0.7.0 version.
- `NoApp` and `NoData` for channels without app.
- Proposal protocol now has shared nonce generation.
- Optimized secondary settlements.
- Channel.Update now only receives `State`, `ActorIdx` is automatically set
  to own index.

Charon - 2020-05-29
Added persistence module to persist channel state data and handle client
shutdowns/restarts, as well as disconnects/reconnects.

Added:
- Persistence:
  - Persister, Restorer, ChannelIterator interfaces to allow for multiple
    persistence implementations.
    - sortedkv implementation provided (in-memory and LevelDB).
  - States and signatures are constantly persisted while channels progress.
  - Clients restore all saved channels on startup. State is synchronized with peers.
  - `Client.OnNewChannel` callback registration to deal with restored
    channels.
- Wallet interface for account unlocking abstraction.
  - Used during persistence to restore secret keys for signing.
  - Implemented for the Ethereum and simulated backend.
- Peer disconnect/reconnect handling.
- `Channel.UpdateBy` functional channel update method for better usability.

Changed:
- License changed to Apache 2.0.
- Replaced `Channel.ListenUpdates` and `Client.HandleChannelProposals` with
  `Client.Handle(ProposalHandler, UpdateHandler)` - a single common handler
  routine per client.
- Adapted client to new persistence layer and wallet.
- Made Ethereum interactions idempotent (increased safety).
- Moved subpackage `db` to `pkg/sortedkv`.
- Swapped Balance dimensions of type `channel.Allocation`.
- Random type generators in package `channel/test` now accept options to
  customize random data generation.
- Channels now get automatically closed when peers disconnect (and restored on reconnect).

Fixed:
- Ethereum backend: No funding transactions for zero own initial channel balances.

Belinda - 2020-03-23

Added direct disputes and watcher for two-party ledger channels, much polishing
(refactors, bug fixes, documentation).

- Ledger state channel disputes and watcher.
- `channel.Adjudicator` interface and Ethereum implementation for registering
  channel states and withdrawing concluded channels.
- [Ethereum contracts](https://github.com/perun-network/contracts-eth) for disputes
- Public [Github wiki](https://github.com/perun-network/go-perun/wiki)
- [Godoc](https://pkg.go.dev/perun.network/go-perun)
- Changelog
- [TravisCI](https://travis-ci.org/perun-network)
- [goreportcard](https://goreportcard.com/report/github.com/perun-network/go-perun)
- [codeclimate](https://codeclimate.com/github/perun-network/go-perun)
- TCP and unix socket `peer.Dialer` and `Listener` implementations.
- `Eventually` tester in `pkg/test` to repeatedly run tests until they
  succeed.
- Concurrent testing tool in `pkg/test` to be able to call `require` in tests
  with multiple go routines.

- `client.New` now needs a `Funder` and `Adjudicator`, instead of a `Settler`.
- `Serializable` renamed to `Serializer`.
- Unified backend imports.
- `pkg/io/test/bytewiseReader` to `iotest.OneByteReader`.
- Improved peer message handling mechanism.
- Consistent handling of `nil` arguments in exported functions.
- Many refactors to improve the overall code quality and documentation.
- Updated Ethereum contract bindings to newest version.

- `wallet.Wallet` interface and `sim` backend implementation - it was never used.
- `ethereum` and `sim/wallet.NewAddressFromBytes` - only `wallet.DecodeAddress`
  should be used to create an `Address` from bytes.
- `channel/machine` Phase subscription logic.
- `channel.Settler` interface and backend implementations - replaced by `Adjudicator`.

- Reduced cyclomatic complexity of complex functions.
- Deadlock in two-party payment channel test.
- Ethereum backend test timeouts and instabilities.
- Many minor bug fixes, mainly concurrency issues in tests.