2013-06-13 13:27:23 -05:00
|
|
|
|
2013-12-20 13:19:35 -06:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.Normalize 100.00% (93/93)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.Inverse 100.00% (88/88)
|
2013-12-23 10:59:32 -06:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.Mul2 100.00% (73/73)
|
2014-02-13 10:51:47 -06:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.SquareVal 100.00% (73/73)
|
2013-12-20 13:19:35 -06:00
|
|
|
github.com/conformal/btcec/signature.go parseSig 100.00% (51/51)
|
|
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.addGeneric 100.00% (35/35)
|
|
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.addZ2EqualsOne 100.00% (35/35)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.PutBytes 100.00% (32/32)
|
|
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.addZ1EqualsZ2 100.00% (30/30)
|
|
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.addZ1AndZ2EqualsOne 100.00% (29/29)
|
|
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.addJacobian 100.00% (22/22)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.doubleZ1EqualsOne 100.00% (18/18)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.doubleGeneric 100.00% (18/18)
|
2013-12-23 10:59:32 -06:00
|
|
|
github.com/conformal/btcec/signature.go Signature.Serialize 100.00% (13/13)
|
2014-02-13 10:51:47 -06:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.MulInt 100.00% (12/12)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.fieldJacobianToBigAffine 100.00% (12/12)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.Add2 100.00% (11/11)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.Add 100.00% (11/11)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.NegateVal 100.00% (11/11)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.SetBytes 100.00% (11/11)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.ScalarMult 100.00% (10/10)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.Add 100.00% (10/10)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.Zero 100.00% (10/10)
|
2013-12-28 15:27:48 -06:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.doubleJacobian 100.00% (9/9)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/btcec.go initS256 100.00% (9/9)
|
|
|
|
|
github.com/conformal/btcec/signature.go canonicalizeInt 100.00% (8/8)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/pubkey.go PublicKey.SerializeHybrid 100.00% (7/7)
|
2014-02-13 10:51:47 -06:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.Double 100.00% (7/7)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/pubkey.go PublicKey.SerializeCompressed 100.00% (6/6)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.SetByteSlice 100.00% (5/5)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.bigAffineToField 100.00% (4/4)
|
2014-02-13 10:51:47 -06:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.IsOnCurve 100.00% (4/4)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/pubkey.go PublicKey.SerializeUncompressed 100.00% (4/4)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.SetHex 100.00% (4/4)
|
|
|
|
|
github.com/conformal/btcec/signature.go canonicalPadding 100.00% (4/4)
|
|
|
|
|
github.com/conformal/btcec/privkey.go PrivKeyFromBytes 100.00% (3/3)
|
2014-02-13 10:51:47 -06:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.Bytes 100.00% (3/3)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.SetInt 100.00% (3/3)
|
|
|
|
|
github.com/conformal/btcec/pubkey.go paddedAppend 100.00% (3/3)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.Set 100.00% (2/2)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.String 100.00% (2/2)
|
|
|
|
|
github.com/conformal/btcec/btcec.go S256 100.00% (2/2)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.IsZero 100.00% (2/2)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.Equals 100.00% (2/2)
|
2013-12-20 13:19:35 -06:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.AddInt 100.00% (2/2)
|
|
|
|
|
github.com/conformal/btcec/pubkey.go isOdd 100.00% (1/1)
|
2013-12-28 15:27:48 -06:00
|
|
|
github.com/conformal/btcec/field.go fieldVal.IsOdd 100.00% (1/1)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.ScalarBaseMult 100.00% (1/1)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.QPlus1Div4 100.00% (1/1)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/signature.go ParseSignature 100.00% (1/1)
|
|
|
|
|
github.com/conformal/btcec/signature.go ParseDERSignature 100.00% (1/1)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.Negate 100.00% (1/1)
|
|
|
|
|
github.com/conformal/btcec/btcec.go initAll 100.00% (1/1)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.Square 100.00% (1/1)
|
|
|
|
|
github.com/conformal/btcec/btcec.go KoblitzCurve.Params 100.00% (1/1)
|
|
|
|
|
github.com/conformal/btcec/field.go fieldVal.Mul 100.00% (1/1)
|
2014-03-25 14:46:20 +00:00
|
|
|
github.com/conformal/btcec/pubkey.go ParsePubKey 92.86% (26/28)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/signature.go SignCompact 90.91% (20/22)
|
2014-02-11 01:43:21 +00:00
|
|
|
github.com/conformal/btcec/pubkey.go decompressPoint 88.89% (8/9)
|
|
|
|
|
github.com/conformal/btcec/signature.go recoverKeyFromSignature 86.96% (20/23)
|
|
|
|
|
github.com/conformal/btcec/signature.go RecoverCompact 77.78% (7/9)
|
|
|
|
|
github.com/conformal/btcec/signature.go hashToInt 77.78% (7/9)
|
Optimize public key serialization.
This change removes the internal pad function in favor a more opimized
paddedAppend function. Unlike pad, which would always alloate a new
slice of the desired size and copy the bytes into it, paddedAppend
only appends the leading padding when necesary, and uses the builtin
append to copy the remaining source bytes. pad was also used in
combination with another call to the builtin copy func to copy into a
zeroed byte slice. As the slice is now created using make with an
initial length of zero, this copy can also be removed.
As confirmed by poking the bytes with the unsafe package, gc does not
zero array elements between the len and cap when allocating slices
with make(). In combination with the paddedAppend func, this results
in only a single copy of each byte, with no unnecssary zeroing, when
creating the serialized pubkeys. This has not been tested with other
Go compilers (namely, gccgo and llgo), but the new behavior is still
functionally correct regardless of compiler optimizations.
The TestPad function has been removed as the pad func it tested has
likewise been removed.
ok @davecgh
2014-05-19 21:24:48 -05:00
|
|
|
github.com/conformal/btcec/pubkey.go PublicKey.ToECDSA 0.00% (0/1)
|
|
|
|
|
github.com/conformal/btcec ------------------------------------- 98.58% (902/915)
|
2013-06-13 13:27:23 -05:00
|
|
|
|
