Refactor wallet

[usatie]

Description of the Change

The Wallet related classes in this library focus on non-networking things.

Wallet usage

// Creating wallet
let wallet = Wallet.create(passphrase: "BitcoinKit-sample-wallet", network: .mainnet)

// Get receive address
wallet.address

// Get change address
wallet.changeAddress

// Get all the addresses
wallet.addresses

// Increment address index for receive address
wallet.incrementExternalIndex(by: 1)

// Increment address index for change address
wallet.incrementInternalIndex(by: 1)

// Get private keys for the addresses
wallet.privKeys

Plan, Build, and Sign a transaction

Assume you already have unspent transactions with theire keys.

let unspentTransactions: [UnspentTransaction] = ...
let privKeys: [PrivateKey] = ...

And then, Plan, Build and Sign a transaction.

// 1. Plan a transaction
let planner = TransactionPlanner(feePerByte: 1)
let plan = planner.plan(unspentTransactions: unspentTransactions, amount: targetAmount)


// 2. Build an unsigned transaction
let unsignedTx = TransactionBuilder.build(from: plan, toAddress: toAddress, changeAddress: changeAddress)


// 3. Sign the transaction
let sighashHelper = BCHSignatureHashHelper(hashType: .ALL)
let signer = TransactionSigner(unspentTransactions: plan.unspentTransactions, transaction: unsignedTx, sighashHelper: sighashHelper)
let signedTx = signer.sign(with: privKeys)

Benefits

More reliability, testability, and stability.

Possible Drawbacks

Users have to implement networking part on their own.
APIs/SPV etc...

Planning to implement such networking features as a separated framework on top of this library.

Applicable issues

closes #143

[Sajjon]

It would be great to not use an enum for CoinType. But rather let it be a protocol, and then use a struct for coin types declared by this library. But internally also be using the protocol of course. Exactly like you did with CoinTypeEntity , and the static variables. Then other DLTs can use BitcoinKit. Actually we at Radix DLT use it in our Swift Library.

So something like this:

public protocol CoinTypeConvertible {
    /// BIP44 cointype value
    var index: UInt32 { get }
    var symbol: String { get }
    var name: String { get }
}

public struct CoinType: CoinTypeConvertible {
    public let index: UInt32
    public let symbol: String
    public let name: String
}

public extension CoinType {
    static let testnet = CoinType(1, "", "Testnet (all coins)")

    static let btc = CoinType(0, "BTC", "Bitcoin")
    static let bch = CoinType(145, "BCH", "Bitcoin Cash")
}

// Ethereum and Zilliqa etc can now use BitcoinKit (both uses curve `Secp256k1`)
public extension CoinTypeEntity {
    static let ethereum = CoinType(60, "ETH", "Ether")
    static let zilliqa = CoinType(313, "ZIL", "Zilliqa")
}

What do you think? :)

[usatie]

It makes sense.
Thank you for your feedback!

[usatie]

But why do we still need CoinTypeConvertible protocol?
I think we can just have CoinType struct.

[Sajjon]

maybe Network can be merged together with new CoinType, being a protocol and "open enum" (struct, not an enum) to ease of use for other DLTs :)

[usatie]

I look into Network, and now I realize that it definitely needs more refactorization.
But I want to leave it for now. It's going to be another PR.