Make a Note on Licensing, Sources, and Copyrights

[watfordjc]

Feature Branch

Current feature branch for this issue: not created yet.

Progress

• Make note of external sources of code and copyrights/licences.
• Update/add comments when additional sources are used.

---

Background

Because of the nature of the application, it is going to be based upon various sources, including algorithms, Bitcoin Improvement Proposals (BIPs), Satoshi Labs Improvement Proposals (SLIPs), Requests For Comments (RFCs), articles, code samples, my original code, etc.

Ordinarily, I would just add the copyright lines to the LICENSE file if published under a compatible licence and/or requires the copyright notice line(s) be included in any subsequent work.

The purpose of this issue is to make a note of the sources of code the code in this repository is built upon, to expand upon the copyright lines in the LICENSE file.

[watfordjc]

Z85

The implementation of the Z85 specification in this repository is based on the Z85 reference implementation written in C.

The Z85 specification is licensed GPL version 3 or later and has the following copyright notice:

Copyright (c) 2013 iMatix Corporation.

The reference implementation is licensed MIT and has the following copyright notice:

Copyright (c) 2010-2013 iMatix Corporation and Contributors

My C# implementation (and any subsequent changes) is based on the reference implementation and has the following copyright notice:

Copyright (c) 2010-2013 iMatix Corporation and Contributors
Copyright (c) 2021-2022 John Cook

RelayCommand, EventRaiser, EventArgs<T>

The classes RelayCommand, EventRaiser, EventArgs<T> (collectively, the RelayCommand classes), are based on the code in the Using RelayCommand / ICommand to handle events in WPF and MVVM article, with the Web site author stating the following on the site's about page:

My postings have been donated to the public domain, including any new posts I write, so they’re not copyrighted. You’re welcome to republish, use, or share them in any way you desire. There’s no need to ask permission in advance.

Andy

The idea of RelayCommand is likely based upon Josh Smith's MSDN article Patterns - WPF Apps With The Model-View-ViewModel Design Pattern. GitHub user djangojazz has copied the code used in that article to a GitHub repository.

Whilst looking for the original source, I noticed some links in Google with titles/descriptions suggesting a potential issue with the original source, that suggest a possible memory leak. I may need to look more at the issue, see if the issue exists in the code I'm using, and work out how to mitigate the issue.

BIP-0039

BIP-0039, or BIP39, is Bitcoin Improvement Proposal number 39, with title Mnemonic code for generating deterministic keys.

BIP39's authors are Marek Palatinus, Pavol Rusnak, Aaron Voisine, Sean Bowe.

The American English word list from BIP39 is used in some form in this application (currently, by functions TryGetIntFromWord() and TryGetWordFromInt()), and the test vectors used in the Tests package are those from Trezor that are referenced in the BIP39 proposal.

All of the code in this application implementing BIP39 is my own. Given the amount of maths involved in splitting bytes into 11 bit chunks, creating/confirming the checksum, et cetera, there is a reason my implementation is heavily commented (it took me a while to get the maths working, particularly the bit shifts).

Having said that, my code implements the maths in BIP39 in a way that looks obvious, so I consider the code for the maths to be an obvious implementation and probably not subject to copyright for reason of obviousness. Likewise, there are probably some obvious optimisations that could be made to my implementation that I would eventually notice if I looked at the code long enough.

SLIP-0021

SLIP-0021, or SLIP21, is Satoshi Labs Improvement Proposal 21, with title Hierarchical derivation of symmetric keys.

SLIP21's authors are Andrew R. Kozlik, Ondrej Vejpustek, Pavol Rusnak.

All of the code in this application implementing SLIP21 is my own, implementing in code the maths described in SLIP-0021 with references to BIP-0032.

The test vectors used in the Tests package are those from SLIP-0021.

ViewModelBase

The class ViewModelBase is based upon various sources, that seem to be based themselves upon various sources such as the BindableBase class in MIT-licensed Prism framework.

Prism has the following copyright notice:

Copyright (c) .NET Foundation

SecureString to char[]

At present, my method of converting a SecureString to a byte[] and then a UTF-8 char[] is based on a StackOverflow answer to a question with title "C# convert SecureString to UTF-8 byte[] securely".

The author of the answer follows up with a comment, linking to the class in their GitHub repository that the answer is based upon, with the repository using The Unlicense.

MVVM Pattern

The Model-View-ViewModel pattern (MVVM) is one way of achieving a separation of concerns, and one of the typical patterns used in C# WPF development. The Model-View-Container (MVC) pattern is the other typical pattern.

I don't particularly like using frameworks when programming because I find they tend to obscure what the code is really doing, so the namespace/folder layout used, the naming of files and classes, and which files are used for which functionality, is based upon what various sources say is "the right way".

Some of my other C# WPF projects that have reached the point of having a release build package created have gone through the process of being refactored into using the MVVM pattern, but I haven't yet settled on what my "right way" is. For example, the start of my refactoring had me turn to my 16 page note document MVVM that is some handwritten source code based on a YouTube tutorial series about MVVM, but I have deviated from it in my MVVM refactoring branch.

Switching to the MVVM pattern, or other refactoring of code to split things into smaller files, is not really a question about licensing or copyright. It is something that happens when a project reaches the point where the file(s) are becoming so long they are becoming unwieldly.