@@ -20,7 +20,7 @@  | 
                                                    ||
| 20 | 20 | private $hash;  | 
                                                        
| 21 | 21 | |
| 22 | 22 | /**  | 
                                                        
| 23 | - * @param BufferInterface $hash  | 
                                                        |
| 23 | + * @param Buffer $hash  | 
                                                        |
| 24 | 24 | */  | 
                                                        
| 25 | 25 | public function __construct(BufferInterface $hash)  | 
                                                        
| 26 | 26 |      { | 
                                                        
@@ -81,7 +81,7 @@ discard block  | 
                                                    ||
| 81 | 81 | * Calculate a checksum for the given data  | 
                                                        
| 82 | 82 | *  | 
                                                        
| 83 | 83 | * @param BufferInterface $data  | 
                                                        
| 84 | - * @return BufferInterface  | 
                                                        |
| 84 | + * @return Buffer  | 
                                                        |
| 85 | 85 | */  | 
                                                        
| 86 | 86 | public static function checksum(BufferInterface $data)  | 
                                                        
| 87 | 87 |      { | 
                                                        
@@ -92,7 +92,7 @@ discard block  | 
                                                    ||
| 92 | 92 | * Decode a base58 checksum string and validate checksum  | 
                                                        
| 93 | 93 | *  | 
                                                        
| 94 | 94 | * @param string $base58  | 
                                                        
| 95 | - * @return BufferInterface  | 
                                                        |
| 95 | + * @return Buffer  | 
                                                        |
| 96 | 96 | * @throws Base58ChecksumFailure  | 
                                                        
| 97 | 97 | */  | 
                                                        
| 98 | 98 | public static function decodeCheck($base58)  | 
                                                        
@@ -111,7 +111,7 @@ discard block  | 
                                                    ||
| 111 | 111 | /**  | 
                                                        
| 112 | 112 | * Encode the given data in base58, with a checksum to check integrity.  | 
                                                        
| 113 | 113 | *  | 
                                                        
| 114 | - * @param BufferInterface $data  | 
                                                        |
| 114 | + * @param Buffer $data  | 
                                                        |
| 115 | 115 | * @return string  | 
                                                        
| 116 | 116 | * @throws \Exception  | 
                                                        
| 117 | 117 | */  | 
                                                        
@@ -90,7 +90,7 @@  | 
                                                    ||
| 90 | 90 | }  | 
                                                        
| 91 | 91 | |
| 92 | 92 | /**  | 
                                                        
| 93 | - * @return BufferInterface  | 
                                                        |
| 93 | + * @return Buffer  | 
                                                        |
| 94 | 94 | */  | 
                                                        
| 95 | 95 | public function getHash()  | 
                                                        
| 96 | 96 |      { | 
                                                        
@@ -50,7 +50,7 @@ discard block  | 
                                                    ||
| 50 | 50 | /**  | 
                                                        
| 51 | 51 | * Set the last hash. Should only be set by calculateHash()  | 
                                                        
| 52 | 52 | *  | 
                                                        
| 53 | - * @param BufferInterface $lastHash  | 
                                                        |
| 53 | + * @param Buffer $lastHash  | 
                                                        |
| 54 | 54 | */  | 
                                                        
| 55 | 55 | private function setLastHash(BufferInterface $lastHash)  | 
                                                        
| 56 | 56 |      { | 
                                                        
@@ -59,7 +59,7 @@ discard block  | 
                                                    ||
| 59 | 59 | |
| 60 | 60 | /**  | 
                                                        
| 61 | 61 | * @param callable|null $hashFunction  | 
                                                        
| 62 | - * @return BufferInterface  | 
                                                        |
| 62 | + * @return Buffer  | 
                                                        |
| 63 | 63 | * @throws MerkleTreeEmpty  | 
                                                        
| 64 | 64 | */  | 
                                                        
| 65 | 65 | public function calculateHash(callable $hashFunction = null)  | 
                                                        
@@ -6,7 +6,6 @@  | 
                                                    ||
| 6 | 6 | use BitWasp\Bitcoin\Collection\Transaction\TransactionCollection;  | 
                                                        
| 7 | 7 | use BitWasp\Buffertools\Buffer;  | 
                                                        
| 8 | 8 | use BitWasp\Buffertools\BufferInterface;  | 
                                                        
| 9 | -use BitWasp\Buffertools\Buffertools;  | 
                                                        |
| 10 | 9 | use BitWasp\Bitcoin\Exceptions\MerkleTreeEmpty;  | 
                                                        
| 11 | 10 | use Pleo\Merkle\FixedSizeTree;  | 
                                                        
| 12 | 11 | |
@@ -263,7 +263,7 @@ discard block  | 
                                                    ||
| 263 | 263 | }  | 
                                                        
| 264 | 264 | |
| 265 | 265 | /**  | 
                                                        
| 266 | - * @param BufferInterface $data  | 
                                                        |
| 266 | + * @param Buffer $data  | 
                                                        |
| 267 | 267 | * @return $this  | 
                                                        
| 268 | 268 | */  | 
                                                        
| 269 | 269 | public function insertData(BufferInterface $data)  | 
                                                        
@@ -291,7 +291,7 @@ discard block  | 
                                                    ||
| 291 | 291 | }  | 
                                                        
| 292 | 292 | |
| 293 | 293 | /**  | 
                                                        
| 294 | - * @param BufferInterface $data  | 
                                                        |
| 294 | + * @param Buffer $data  | 
                                                        |
| 295 | 295 | * @return bool  | 
                                                        
| 296 | 296 | */  | 
                                                        
| 297 | 297 | public function containsData(BufferInterface $data)  | 
                                                        
@@ -33,7 +33,7 @@ discard block  | 
                                                    ||
| 33 | 33 | |
| 34 | 34 | /**  | 
                                                        
| 35 | 35 | * @param BufferInterface $bits  | 
                                                        
| 36 | - * @return int|string  | 
                                                        |
| 36 | + * @return string  | 
                                                        |
| 37 | 37 | */  | 
                                                        
| 38 | 38 | public function getTarget(BufferInterface $bits)  | 
                                                        
| 39 | 39 |      { | 
                                                        
@@ -43,7 +43,7 @@ discard block  | 
                                                    ||
| 43 | 43 | }  | 
                                                        
| 44 | 44 | |
| 45 | 45 | /**  | 
                                                        
| 46 | - * @return int|string  | 
                                                        |
| 46 | + * @return string  | 
                                                        |
| 47 | 47 | */  | 
                                                        
| 48 | 48 | public function getMaxTarget()  | 
                                                        
| 49 | 49 |      { | 
                                                        
@@ -52,7 +52,7 @@ discard block  | 
                                                    ||
| 52 | 52 | |
| 53 | 53 | /**  | 
                                                        
| 54 | 54 | * @param BufferInterface $bits  | 
                                                        
| 55 | - * @return BufferInterface  | 
                                                        |
| 55 | + * @return Buffer  | 
                                                        |
| 56 | 56 | */  | 
                                                        
| 57 | 57 | public function getTargetHash(BufferInterface $bits)  | 
                                                        
| 58 | 58 |      { | 
                                                        
@@ -82,7 +82,7 @@ discard block  | 
                                                    ||
| 82 | 82 | }  | 
                                                        
| 83 | 83 | |
| 84 | 84 | /**  | 
                                                        
| 85 | - * @param BufferInterface $hash  | 
                                                        |
| 85 | + * @param Buffer $hash  | 
                                                        |
| 86 | 86 | * @param int|string $nBits  | 
                                                        
| 87 | 87 | * @return bool  | 
                                                        
| 88 | 88 | */  | 
                                                        
@@ -114,7 +114,7 @@ discard block  | 
                                                    ||
| 114 | 114 | |
| 115 | 115 | /**  | 
                                                        
| 116 | 116 | * @param BufferInterface $bits  | 
                                                        
| 117 | - * @return int|string  | 
                                                        |
| 117 | + * @return string  | 
                                                        |
| 118 | 118 | */  | 
                                                        
| 119 | 119 | public function getWork(BufferInterface $bits)  | 
                                                        
| 120 | 120 |      { | 
                                                        
@@ -254,8 +254,8 @@ discard block  | 
                                                    ||
| 254 | 254 | /**  | 
                                                        
| 255 | 255 | * Attempt to calculate the public key recovery param by trial and error  | 
                                                        
| 256 | 256 | *  | 
                                                        
| 257 | - * @param int|string $r  | 
                                                        |
| 258 | - * @param int|string $s  | 
                                                        |
| 257 | + * @param integer $r  | 
                                                        |
| 258 | + * @param integer $s  | 
                                                        |
| 259 | 259 | * @param BufferInterface $messageHash  | 
                                                        
| 260 | 260 | * @param PublicKey $publicKey  | 
                                                        
| 261 | 261 | * @return int  | 
                                                        
@@ -313,7 +313,7 @@ discard block  | 
                                                    ||
| 313 | 313 | }  | 
                                                        
| 314 | 314 | |
| 315 | 315 | /**  | 
                                                        
| 316 | - * @param BufferInterface $privateKey  | 
                                                        |
| 316 | + * @param Buffer $privateKey  | 
                                                        |
| 317 | 317 | * @return bool  | 
                                                        
| 318 | 318 | */  | 
                                                        
| 319 | 319 | public function validatePrivateKey(BufferInterface $privateKey)  | 
                                                        
@@ -324,7 +324,7 @@ discard block  | 
                                                    ||
| 324 | 324 | }  | 
                                                        
| 325 | 325 | |
| 326 | 326 | /**  | 
                                                        
| 327 | - * @param int|string $element  | 
                                                        |
| 327 | + * @param string $element  | 
                                                        |
| 328 | 328 | * @param bool $half  | 
                                                        
| 329 | 329 | * @return bool  | 
                                                        
| 330 | 330 | */  | 
                                                        
@@ -340,7 +340,7 @@ discard block  | 
                                                    ||
| 340 | 340 | }  | 
                                                        
| 341 | 341 | |
| 342 | 342 | /**  | 
                                                        
| 343 | - * @param BufferInterface $publicKey  | 
                                                        |
| 343 | + * @param Buffer $publicKey  | 
                                                        |
| 344 | 344 | * @return PublicKeyInterface  | 
                                                        
| 345 | 345 | * @throws \Exception  | 
                                                        
| 346 | 346 | */  | 
                                                        
@@ -14,7 +14,6 @@  | 
                                                    ||
| 14 | 14 | use BitWasp\Bitcoin\Math\Math;  | 
                                                        
| 15 | 15 | use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Key\PrivateKey;  | 
                                                        
| 16 | 16 | use BitWasp\Bitcoin\Crypto\EcAdapter\Impl\PhpEcc\Signature\CompactSignature;  | 
                                                        
| 17 | -use BitWasp\Buffertools\Buffer;  | 
                                                        |
| 18 | 17 | use BitWasp\Buffertools\BufferInterface;  | 
                                                        
| 19 | 18 | use Mdanter\Ecc\Primitives\GeneratorPoint;  | 
                                                        
| 20 | 19 | use Mdanter\Ecc\Primitives\PointInterface;  | 
                                                        
@@ -66,7 +66,7 @@  | 
                                                    ||
| 66 | 66 | }  | 
                                                        
| 67 | 67 | |
| 68 | 68 | /**  | 
                                                        
| 69 | - * @param BufferInterface $privateKey  | 
                                                        |
| 69 | + * @param Buffer $privateKey  | 
                                                        |
| 70 | 70 | * @return bool  | 
                                                        
| 71 | 71 | */  | 
                                                        
| 72 | 72 | public function validatePrivateKey(BufferInterface $privateKey)  | 
                                                        
@@ -11,7 +11,7 @@ discard block  | 
                                                    ||
| 11 | 11 | * Calculate Sha256(RipeMd160()) on the given data  | 
                                                        
| 12 | 12 | *  | 
                                                        
| 13 | 13 | * @param BufferInterface $data  | 
                                                        
| 14 | - * @return BufferInterface  | 
                                                        |
| 14 | + * @return Buffer  | 
                                                        |
| 15 | 15 | */  | 
                                                        
| 16 | 16 | public static function sha256ripe160(BufferInterface $data)  | 
                                                        
| 17 | 17 |      { | 
                                                        
@@ -22,7 +22,7 @@ discard block  | 
                                                    ||
| 22 | 22 | * Perform SHA256  | 
                                                        
| 23 | 23 | *  | 
                                                        
| 24 | 24 | * @param BufferInterface $data  | 
                                                        
| 25 | - * @return BufferInterface  | 
                                                        |
| 25 | + * @return Buffer  | 
                                                        |
| 26 | 26 | */  | 
                                                        
| 27 | 27 | public static function sha256(BufferInterface $data)  | 
                                                        
| 28 | 28 |      { | 
                                                        
@@ -33,7 +33,7 @@ discard block  | 
                                                    ||
| 33 | 33 | * Perform SHA256 twice  | 
                                                        
| 34 | 34 | *  | 
                                                        
| 35 | 35 | * @param BufferInterface $data  | 
                                                        
| 36 | - * @return BufferInterface  | 
                                                        |
| 36 | + * @return Buffer  | 
                                                        |
| 37 | 37 | */  | 
                                                        
| 38 | 38 | public static function sha256d(BufferInterface $data)  | 
                                                        
| 39 | 39 |      { | 
                                                        
@@ -44,7 +44,7 @@ discard block  | 
                                                    ||
| 44 | 44 | * RIPEMD160  | 
                                                        
| 45 | 45 | *  | 
                                                        
| 46 | 46 | * @param BufferInterface $data  | 
                                                        
| 47 | - * @return BufferInterface  | 
                                                        |
| 47 | + * @return Buffer  | 
                                                        |
| 48 | 48 | */  | 
                                                        
| 49 | 49 | public static function ripemd160(BufferInterface $data)  | 
                                                        
| 50 | 50 |      { | 
                                                        
@@ -55,7 +55,7 @@ discard block  | 
                                                    ||
| 55 | 55 | * RIPEMD160 twice  | 
                                                        
| 56 | 56 | *  | 
                                                        
| 57 | 57 | * @param BufferInterface $data  | 
                                                        
| 58 | - * @return BufferInterface  | 
                                                        |
| 58 | + * @return Buffer  | 
                                                        |
| 59 | 59 | */  | 
                                                        
| 60 | 60 | public static function ripemd160d(BufferInterface $data)  | 
                                                        
| 61 | 61 |      { | 
                                                        
@@ -66,7 +66,7 @@ discard block  | 
                                                    ||
| 66 | 66 | * Calculate a SHA1 hash  | 
                                                        
| 67 | 67 | *  | 
                                                        
| 68 | 68 | * @param BufferInterface $data  | 
                                                        
| 69 | - * @return BufferInterface  | 
                                                        |
| 69 | + * @return Buffer  | 
                                                        |
| 70 | 70 | */  | 
                                                        
| 71 | 71 | public static function sha1(BufferInterface $data)  | 
                                                        
| 72 | 72 |      { | 
                                                        
@@ -77,11 +77,11 @@ discard block  | 
                                                    ||
| 77 | 77 | * PBKDF2  | 
                                                        
| 78 | 78 | *  | 
                                                        
| 79 | 79 | * @param string $algorithm  | 
                                                        
| 80 | - * @param BufferInterface $password  | 
                                                        |
| 81 | - * @param BufferInterface $salt  | 
                                                        |
| 80 | + * @param Buffer $password  | 
                                                        |
| 81 | + * @param Buffer $salt  | 
                                                        |
| 82 | 82 | * @param integer $count  | 
                                                        
| 83 | 83 | * @param integer $keyLength  | 
                                                        
| 84 | - * @return BufferInterface  | 
                                                        |
| 84 | + * @return Buffer  | 
                                                        |
| 85 | 85 | * @throws \Exception  | 
                                                        
| 86 | 86 | */  | 
                                                        
| 87 | 87 | public static function pbkdf2($algorithm, BufferInterface $password, BufferInterface $salt, $count, $keyLength)  | 
                                                        
@@ -102,7 +102,7 @@ discard block  | 
                                                    ||
| 102 | 102 | /**  | 
                                                        
| 103 | 103 | * @param BufferInterface $data  | 
                                                        
| 104 | 104 | * @param int $seed  | 
                                                        
| 105 | - * @return BufferInterface  | 
                                                        |
| 105 | + * @return Buffer  | 
                                                        |
| 106 | 106 | */  | 
                                                        
| 107 | 107 | public static function murmur3(BufferInterface $data, $seed)  | 
                                                        
| 108 | 108 |      { | 
                                                        
@@ -114,8 +114,8 @@ discard block  | 
                                                    ||
| 114 | 114 | *  | 
                                                        
| 115 | 115 | * @param string $algo  | 
                                                        
| 116 | 116 | * @param BufferInterface $data  | 
                                                        
| 117 | - * @param BufferInterface $salt  | 
                                                        |
| 118 | - * @return BufferInterface  | 
                                                        |
| 117 | + * @param Buffer $salt  | 
                                                        |
| 118 | + * @return Buffer  | 
                                                        |
| 119 | 119 | */  | 
                                                        
| 120 | 120 | public static function hmac($algo, BufferInterface $data, BufferInterface $salt)  | 
                                                        
| 121 | 121 |      { |