Crypto

Type Members

case class Point(value: ECPoint) extends Product with Serializable

Curve point
Curve point
value
ecPoint to initialize this point with
case class PointProxy(bin: BinaryData) extends Product with Serializable
case class PrivateKey(value: Scalar, compressed: Boolean = true) extends Product with Serializable

value
value of this private key (a number)
compressed
flags which specifies if the associated public key will be compressed or uncompressed.
case class PublicKey(raw: BinaryData, checkValid: Boolean = true) extends Product with Serializable

raw
serialized value of this public key (a point)
checkValid
indicates whether or not we check that this is a valid public key; this should be used carefully for optimization purposes
case class Scalar(value: BigInteger) extends Product with Serializable

A scalar is a 256 bit number
A scalar is a 256 bit number
value
value to initialize this scalar with

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object Point extends Serializable
object PrivateKey extends Serializable
object PublicKey extends Serializable
object Scalar extends Serializable
final def asInstanceOf[T0]: T0

Definition Classes
Any
implicit def biginteger2scalar(value: BigInteger): Scalar
implicit def bin2scalar(value: BinaryData): Scalar
def checkDataSignatureEncoding(sig: Seq[Byte], flags: Int): Boolean
def checkPubKeyEncoding(key: Seq[Byte], flags: Int): Boolean
def checkRawECDSASignatureEncoding(sig: Seq[Byte], flags: Int): Boolean
def checkRawSignatureEncoding(sig: Seq[Byte], flags: Int): Boolean
def checkTransactionSignatureEncoding(sig: Seq[Byte], flags: Int, supportSchnorr: Boolean): Boolean
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val curve: ECDomainParameters
def decodeSignature(blob: Seq[Byte]): (BigInteger, BigInteger)

An ECDSA signature is a (r, s) pair.
An ECDSA signature is a (r, s) pair. Bitcoin uses DER encoded signatures
blob
sigbyte data
returns
the decoded (r, s) signature
def decodeSignatureLax(input: BinaryData): (BigInteger, BigInteger)
def decodeSignatureLax(input: ByteArrayInputStream): (BigInteger, BigInteger)
def ecdh(priv: Scalar, pub: Point): BinaryData

Computes ecdh using secp256k1's variant: sha256(priv * pub serialized in compressed format)
Computes ecdh using secp256k1's variant: sha256(priv * pub serialized in compressed format)
priv
private value
pub
public value
returns
ecdh(priv, pub) as computed by libsecp256k1
implicit def ecpoint2point(value: ECPoint): Point
def encodeSignature(t: (BigInteger, BigInteger)): BinaryData
def encodeSignature(r: BigInteger, s: BigInteger): BinaryData

An ECDSA signature is a (r, s) pair.
An ECDSA signature is a (r, s) pair. Bitcoin uses DER encoded signatures
r
first value
s
second value
returns
(r, s) in DER format
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def fixSize(data: BinaryData): BinaryData
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getHashType(sig: Seq[Byte]): Int
val halfCurveOrder: BigInteger
def hash(digest: Digest)(input: Seq[Byte]): BinaryData
def hash160(input: Seq[Byte]): BinaryData

160 bits bitcoin hash, used mostly for address encoding hash160(input) = RIPEMD160(SHA256(input))
160 bits bitcoin hash, used mostly for address encoding hash160(input) = RIPEMD160(SHA256(input))
input
array of byte
returns
the 160 bits BTC hash of input
def hash256(input: Seq[Byte]): BinaryData

256 bits bitcoin hash hash256(input) = SHA256(SHA256(input))
256 bits bitcoin hash hash256(input) = SHA256(SHA256(input))
input
array of byte
returns
the 256 bits BTC hash of input
def hashCode(): Int

Definition Classes
AnyRef → Any
def hmac512(key: Seq[Byte], data: Seq[Byte]): BinaryData
def isDefinedHashtypeSignature(sig: Seq[Byte]): Boolean
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isLowDERSignature(sig: Seq[Byte]): Boolean
def isPrivateKeyCompressed(key: PrivateKey): Boolean
def isPubKeyCompressed(key: Seq[Byte]): Boolean
def isPubKeyCompressedOrUncompressed(key: Seq[Byte]): Boolean
def isPubKeyValid(key: Seq[Byte]): Boolean

key
serialized public key
returns
true if the key is valid. Please not that this performs very basic tests and does not check that the point represented by this key is actually valid.
def isValidDERSignatureEncoding(sig: Seq[Byte]): Boolean
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def normalizeSignature(sig: BinaryData): BinaryData
def normalizeSignature(r: BigInteger, s: BigInteger): (BigInteger, BigInteger)
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
val one: BigInteger
val params: X9ECParameters
implicit def point2ecpoint(point: Point): ECPoint
implicit def privatekey2scalar(priv: PrivateKey): Scalar
def publicKeyFromPrivateKey(privateKey: BinaryData): PublicKey

privateKey
private key
returns
the corresponding public key
implicit def publickey2bin(pub: PublicKey): BinaryData
implicit def publickey2point(pub: PublicKey): Point
def recoverPoint(x: BigInteger): (Point, Point)

x
x coordinate
returns
a tuple (p1, p2) where p1 and p2 are points on the curve and p1.x = p2.x = x p1.y is even, p2.y is odd
def recoverPublicKey(sig: BinaryData, message: BinaryData): (PublicKey, PublicKey)
def recoverPublicKey(t: (BigInteger, BigInteger), message: BinaryData): (PublicKey, PublicKey)

Recover public keys from a signature and the message that was signed.
Recover public keys from a signature and the message that was signed. This method will return 2 public keys, and the signature can be verified with both, but only one of them matches that private key that was used to generate the signature.
t
signature
message
message that was signed
returns
a (pub1, pub2) tuple where pub1 and pub2 are candidates public keys. If you have the recovery id then use pub1 if the recovery id is even and pub2 if it is odd
def ripemd160: (Seq[Byte]) ⇒ BinaryData
implicit def scalar2biginteger(scalar: Scalar): BigInteger
implicit def scalar2bin(scalar: Scalar): BinaryData
def sha1: (Seq[Byte]) ⇒ BinaryData
def sha256: (Seq[Byte]) ⇒ BinaryData
def sign(data: BinaryData, privateKey: PrivateKey): (BigInteger, BigInteger)

Sign data with a private key, using RCF6979 deterministic signatures
Sign data with a private key, using RCF6979 deterministic signatures
data
data to sign
privateKey
private key. If you are using bitcoin "compressed" private keys make sure to only use the first 32 bytes of the key (there is an extra "1" appended to the key)
returns
a (r, s) ECDSA signature pair
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def verifyECDSA(data: BinaryData, signature: BinaryData, publicKey: PublicKey): Boolean
def verifySchnorr(data: BinaryData, signature: BinaryData, publicKey: PublicKey): Boolean
def verifySignature(data: BinaryData, signature: BinaryData, publicKey: PublicKey, flags: Int): Boolean

data
data
signature
signature
publicKey
public key
returns
true is signature is valid for this data with this public key
def verifySignature(data: Seq[Byte], signature: (BigInteger, BigInteger), publicKey: PublicKey, flags: Int): Boolean
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
val zero: BigInteger

Related Doc: package bitcoincash

object Crypto

Type Members

case class Point(value: ECPoint) extends Product with Serializable

case class PointProxy(bin: BinaryData) extends Product with Serializable

case class PrivateKey(value: Scalar, compressed: Boolean = true) extends Product with Serializable

case class PublicKey(raw: BinaryData, checkValid: Boolean = true) extends Product with Serializable

case class Scalar(value: BigInteger) extends Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Point extends Serializable

object PrivateKey extends Serializable

object PublicKey extends Serializable

object Scalar extends Serializable

final def asInstanceOf[T0]: T0

implicit def biginteger2scalar(value: BigInteger): Scalar

implicit def bin2scalar(value: BinaryData): Scalar

def checkDataSignatureEncoding(sig: Seq[Byte], flags: Int): Boolean

def checkPubKeyEncoding(key: Seq[Byte], flags: Int): Boolean

def checkRawECDSASignatureEncoding(sig: Seq[Byte], flags: Int): Boolean

def checkRawSignatureEncoding(sig: Seq[Byte], flags: Int): Boolean

def checkTransactionSignatureEncoding(sig: Seq[Byte], flags: Int, supportSchnorr: Boolean): Boolean

def clone(): AnyRef

val curve: ECDomainParameters

def decodeSignature(blob: Seq[Byte]): (BigInteger, BigInteger)

def decodeSignatureLax(input: BinaryData): (BigInteger, BigInteger)

def decodeSignatureLax(input: ByteArrayInputStream): (BigInteger, BigInteger)

def ecdh(priv: Scalar, pub: Point): BinaryData

implicit def ecpoint2point(value: ECPoint): Point

def encodeSignature(t: (BigInteger, BigInteger)): BinaryData

def encodeSignature(r: BigInteger, s: BigInteger): BinaryData

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fixSize(data: BinaryData): BinaryData

final def getClass(): Class[_]

def getHashType(sig: Seq[Byte]): Int

val halfCurveOrder: BigInteger

def hash(digest: Digest)(input: Seq[Byte]): BinaryData

def hash160(input: Seq[Byte]): BinaryData

def hash256(input: Seq[Byte]): BinaryData

def hashCode(): Int

def hmac512(key: Seq[Byte], data: Seq[Byte]): BinaryData

def isDefinedHashtypeSignature(sig: Seq[Byte]): Boolean

final def isInstanceOf[T0]: Boolean

def isLowDERSignature(sig: Seq[Byte]): Boolean

def isPrivateKeyCompressed(key: PrivateKey): Boolean

def isPubKeyCompressed(key: Seq[Byte]): Boolean

def isPubKeyCompressedOrUncompressed(key: Seq[Byte]): Boolean

def isPubKeyValid(key: Seq[Byte]): Boolean

def isValidDERSignatureEncoding(sig: Seq[Byte]): Boolean

final def ne(arg0: AnyRef): Boolean

def normalizeSignature(sig: BinaryData): BinaryData

def normalizeSignature(r: BigInteger, s: BigInteger): (BigInteger, BigInteger)

final def notify(): Unit

final def notifyAll(): Unit

val one: BigInteger

val params: X9ECParameters

implicit def point2ecpoint(point: Point): ECPoint

implicit def privatekey2scalar(priv: PrivateKey): Scalar

def publicKeyFromPrivateKey(privateKey: BinaryData): PublicKey

implicit def publickey2bin(pub: PublicKey): BinaryData

implicit def publickey2point(pub: PublicKey): Point

def recoverPoint(x: BigInteger): (Point, Point)

def recoverPublicKey(sig: BinaryData, message: BinaryData): (PublicKey, PublicKey)

def recoverPublicKey(t: (BigInteger, BigInteger), message: BinaryData): (PublicKey, PublicKey)

def ripemd160: (Seq[Byte]) ⇒ BinaryData

implicit def scalar2biginteger(scalar: Scalar): BigInteger

implicit def scalar2bin(scalar: Scalar): BinaryData

def sha1: (Seq[Byte]) ⇒ BinaryData

def sha256: (Seq[Byte]) ⇒ BinaryData

def sign(data: BinaryData, privateKey: PrivateKey): (BigInteger, BigInteger)

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def verifyECDSA(data: BinaryData, signature: BinaryData, publicKey: PublicKey): Boolean

def verifySchnorr(data: BinaryData, signature: BinaryData, publicKey: PublicKey): Boolean

def verifySignature(data: BinaryData, signature: BinaryData, publicKey: PublicKey, flags: Int): Boolean