horizontalsystems/bitcoin-kit-ios

Comprehensive Bitcoin development library for iOS, implemented on Swift. SPV wallet implementation for Bitcoin, Bitcoin Cash, Litecoin and Dash blockchains. Comprehensive Bitcoin development library for iOS, implemented on Swift. SPV wallet implementation for Bitcoin, Bitcoin Cash, Litecoin and Dash blockchains. Fully compliant with existing standards and BIPs.

bitcoin-kit-ios's Issues

Add multisig transaction extractors. Check other types of transactions.

Some transactions from TestNet are marked as "invalid"

It happens because TransactionExtractor cannot extract any data from a transaction.
It is incorrect behavior, because we should handle all transaction, even if we were not able to extract any "pubic key" or "address" data from it.

InitialSyncer does not add generated keys to PeerGroup

InitialSyncer should generate new public keys (addresses) using AddressManager.
AddressManager should report newly generated keys to PeerGroup.

PeerGroup Windowed Download

PeerGroup should download blocks by "windows". Window means that it should concurrently download blocks in a range and provide it to app.
Application on the other hand - should request to download blocks by serial windows.

Update WalletKitPrivate class with swift implementation available in BitcoinKit

Currently there are files Crypto/WalletKitPrivate.m and Crypto/WalletKitPrivate.h which are swift implementations of some cryptographic algorithms used in bitcoin. Sometimes we get exceptions in Crypto/WalletKitPrivate.m#43 saying that key variable is NULL.

There's a new swift implementation available in BitcoinKit. Let's try to use them.

Set address and keyhash in input derived from previous output if exists

Currently, if we can't extract keyhash from input scriptSig we leave as unknown input.
TransactionLinker should look for previous output of unknown inputs and set keyhash if output exists

Implement Fork Handler

Now HeaderHandler rejects all block headers that are not in its chain.
Instead it should check incoming block headers for the case of fork. If incoming headers are more "valid" than the chain on our database - it should replace it.

Validate and save each block header separately, not in a batch

Each header in HeaderHandler should be validated and saved independently.
Creating validated block should be extracted into separate class (ValidatedBlockFactory).

AddressManager tries to create keys with index starting with 0 even if there are existing, but used keys

Refactor transaction for witness fields.

Checkpoint block in not synced on initial sync

This happens because header handler saves the checkpoint block to database along with the received headers, but does not report it to PeerGroup.

Refactor PeerGroup and Peer classes using PeerTask's

• Create new PeerTask class for abstracting all app related tasks that are performed by Peers.
• PeerGroup is responsible for creating new PeerTasks and distributing them among ready peers.
• Also all peers should be assigned as "sync peer" one by one as they are ready.
• PeerGroup should request header hashes and unsynced block hashes from its delegate in order to be able to create tasks.

InputSignerTests are failing after update of Xcode.

Error message:

dyld: lazy symbol binding failed: Symbol not found: _secp256k1_context_create

Implement block header validators for Bitcoin Cash

Bitcoin block header validators do not work for Bitcoin Cash protocol.
We need to implement new validators for Bitcoin Cash main and test net.

Check bitcoincashj libruary.

Make "header" field optional in Block model

Now "header" field in Block class is explicitly unwrapped optional. It should be made optional in order to avoid runtime crashes.

Add validation address and value for send module.

For mainNet and testNet.

Encapsulate all internal models and logic for WalletKit library

• RealmResults should not be public for transactions and unspent outputs. Simple TransactionInfo structure should be public.
• balance should be fetched simply through Int value.
• all changes should be observed via delegate protocol (realm observers and rx subject should not be used)
• only WalletKit should be public and have public methods.

Update WalletKitPrivate class with swift implementation available in BitcoinKit

Currently there are files Crypto/WalletKitPrivate.m and Crypto/WalletKitPrivate.h which are swift implementations of some cryptographic algorithms used in bitcoin. Sometimes we get exceptions in Crypto/WalletKitPrivate.m#43 saying that key variable is NULL.

There's a new swift implementation available in BitcoinKit. Let's try to use them.

Remove all raw logs and inject Logger into all required places

Now most of the logs are printed directly into console.
It is no suitable when we need to debug and print only certain logs. Logger should be available to turn on/off certain logs.

Cover all PeerGroup related classes with Unit Tests.

As PeerGroup was transferred from Android project - it was not developed using TDD.
All Peer and PeerGroup related logic should be covered with unit tests:

• PeerGroup
• Peer
• PeerConnection
• PeerTask's

Peer Discovery is stuck if any dns is not responding

When discovering new peers for several dns seeds - if any seed will not respond or respond slowly - all peer discovery process is stuck.
Dns seeds should report their discovery results independently from each other.

Adopt InitialSyncer to use IPFS

InitialSyncer should use IPFS server for fetching block hashes before checkpoint block.

Implement resending transactions on app restart.

Transactions are now can be sent only in "real-time". This means that in order for them to be sent successfully we should have started PeerGroup and connected Peers.
We should handle resending transactions when PeerGroup is ready and on app restart as well.

Add Bech32 converter with prefix.

Block Validator is slow

BlockValidator's performance is quite bad. It should be revised and refactored to work faster.

Check BitcoinCash validate algorythm. Add validate BitcoinCash testnet.

Extract address from witness transaction. Add witness types in script type.

Refactor header validators and network protocols.

Rethink usage of all DispatchQueue QOS params

Now all sync and handler jobs use DispatchQueues with qos = .background.
This is not quite correct because some tasks require more priority to make syncing of blockchain faster.
Every DispatchQueue in the app should be reviewed and correct qos should be selected.

BloomFilter optimization

Currently, our peers don't send transactions sending our P2PK outputs. Because, there's nothing matching our PKH/PK in their inputs. For this, FilterLoad message has a nFlag attribute. We should set it to 2 in order for peers to automatically update bloom filter with COutPoints of matched P2PK outputs.

This and this(#94 ) tickets gradually pollute the bloom filter. That's why we should track the false positives ratio and clear/reset bloom filter when that ratio raises

Clear database after full sync

After downloading and parsing all transactions - we can remove all transactions that are not related to our wallet. (they were downloaded by bloom filter false positive rate).
After removing transactions we can also remove all blocks that have no transactions, except the blocks that are required for blockchain validation (2016 last blocks usually).

Save received headers in a batch for better performance

Saving each block (from header) separately is slow, because Realm makes a separate transaction for each item.

Remove BackgroundWorker

This class is not used anymore and can be removed from the project.

Create transaction with witness addresses

Newly generated blocks are not synced correctly when peer is already connected

Steps to reproduce:

• connect to peer
• generate several blocks in blockchain
• see that wallet shows "wrongPreviousHeader" error when trying to sync them

Also please note that these blocks are synced correctly if we reconnect to network and sync them via initial sync.

Update BloomFilter with COutPoint hashes when mine P2WPKH output is detected

Currently, our peers don't send transactions sending our native P2WPKH outputs. Because, they don't test filter against witnessdata, where matching PKH is located. Therefore, we should set COutPoint hashes of those outputs to bloom filter when we detect them.

https://groups.google.com/d/msg/bitcoinj/SJpLgjowc1I/-lOEzZOhBwAJ

Test networks validate method

Transfer PeerGroup implementation from Android project

1. Transfer all unit tests related to PeerGroup from Android project.
2. Transfer PeerGroup related code from Android project and make sure that all unit tests are passing.

AddressManager does not generate gap limit correctly

Now AM uses all unused keys count for calculating gap limit.
But it should use last used key index for this calculations.

ProgressSyncer should report current sync session progress

Now ProgressSyncer reports progress calculated for all blocks in database (synced/non synced).
For the first sync session it shows correct progress, but for later sync sessions it shows incorrect progress.
We should get the last synced block in database and fetch the last block height from sync peer and calculate progress according to this data.

Handle peer array in synced queue

In PeerGroup when new peers are added to peers array - it should be performed in synced queue.

Add timeout for PeerTasks and handle their failures

Every PeerTask should have a timeout and fail itself on timeout.
PeerGroup should handle failed tasks and reassign them to other peers.

Handle Network connection changes

Parse outputs and inputs with right addresses and types (include witness)

Make address class for store not only keyhash data, but address type and other.

Find PublicKey for transaction outputs and inputs by matching with pregenerated keyhashes

Now we determine PublicKey used in the transaction by matching only with publicKeyHash. We should also match with WitnessProgramHash, in order to find our p2wpkh(sh) transactions.

• Use ScriptBuilder for generating p2wpkh(sh) keyhashes
• AddressManager should also generate p2wpkh(sh) for each PublicKey and set that hash to bloomfilter

Check address type to build right transaction for p2pk/h and p2sh types.

Process transactions in order

Current transaction parsing logic is developed for parsing them in random order.
After #83 - all blocks (and their transactions) are downloaded in order. So transaction parsing logic can be simplified according top this changes.

Add "Bitcoin Cash" network type.

Add new network type and configure its checkpoints, magic and other constants.

Extend address for understand witness address. Using bech32