Documentation

Index

Constants

View Source
const DigestLength = 32

    DigestLength sets the signature digest exact length

    View Source
    const RecoveryIDOffset = 64

      RecoveryIDOffset points to the byte offset within the signature that contains the recovery id.

      View Source
      const SignatureLength = 64 + 1 // 64 bytes ECDSA signature + 1 byte recovery id
      

        SignatureLength indicates the byte length required to carry a signature with recovery id.

        Variables

        This section is empty.

        Functions

        func CompressPubkey

        func CompressPubkey(pubkey *ecdsa.PublicKey) []byte

          CompressPubkey encodes a public key to the 33-byte compressed format.

          func CreateAddress

          func CreateAddress(b common.Address, nonce uint64) common.Address

            CreateAddress creates an ethereum address given the bytes and the nonce

            func CreateAddress2

            func CreateAddress2(b common.Address, salt [32]byte, inithash []byte) common.Address

              CreateAddress2 creates an ethereum address given the address bytes, initial contract code hash and a salt.

              func DecompressPubkey

              func DecompressPubkey(pubkey []byte) (*ecdsa.PublicKey, error)

                DecompressPubkey parses a public key in the 33-byte compressed format.

                func Ecrecover

                func Ecrecover(hash, sig []byte) ([]byte, error)

                  Ecrecover returns the uncompressed public key that created the given signature.

                  func FromECDSA

                  func FromECDSA(priv *ecdsa.PrivateKey) []byte

                    FromECDSA exports a private key into a binary dump.

                    func FromECDSAPub

                    func FromECDSAPub(pub *ecdsa.PublicKey) []byte

                    func GenerateKey

                    func GenerateKey() (*ecdsa.PrivateKey, error)

                      GenerateKey generates a new private key.

                      func HashData

                      func HashData(kh KeccakState, data []byte) (h common.Hash)

                        HashData hashes the provided data using the KeccakState and returns a 32 byte hash

                        func HexToECDSA

                        func HexToECDSA(hexkey string) (*ecdsa.PrivateKey, error)

                          HexToECDSA parses a secp256k1 private key.

                          func Keccak256

                          func Keccak256(data ...[]byte) []byte

                            Keccak256 calculates and returns the Keccak256 hash of the input data.

                            func Keccak256Hash

                            func Keccak256Hash(data ...[]byte) (h common.Hash)

                              Keccak256Hash calculates and returns the Keccak256 hash of the input data, converting it to an internal Hash data structure.

                              func Keccak512

                              func Keccak512(data ...[]byte) []byte

                                Keccak512 calculates and returns the Keccak512 hash of the input data.

                                func LoadECDSA

                                func LoadECDSA(file string) (*ecdsa.PrivateKey, error)

                                  LoadECDSA loads a secp256k1 private key from the given file.

                                  func PubkeyToAddress

                                  func PubkeyToAddress(p ecdsa.PublicKey) common.Address

                                  func S256

                                  func S256() elliptic.Curve

                                    S256 returns an instance of the secp256k1 curve.

                                    func SaveECDSA

                                    func SaveECDSA(file string, key *ecdsa.PrivateKey) error

                                      SaveECDSA saves a secp256k1 private key to the given file with restrictive permissions. The key data is saved hex-encoded.

                                      func SigToPub

                                      func SigToPub(hash, sig []byte) (*ecdsa.PublicKey, error)

                                        SigToPub returns the public key that created the given signature.

                                        func Sign

                                        func Sign(digestHash []byte, prv *ecdsa.PrivateKey) (sig []byte, err error)

                                          Sign calculates an ECDSA signature.

                                          This function is susceptible to chosen plaintext attacks that can leak information about the private key that is used for signing. Callers must be aware that the given digest cannot be chosen by an adversery. Common solution is to hash any input before calculating the signature.

                                          The produced signature is in the [R || S || V] format where V is 0 or 1.

                                          func ToECDSA

                                          func ToECDSA(d []byte) (*ecdsa.PrivateKey, error)

                                            ToECDSA creates a private key with the given D value.

                                            func ToECDSAUnsafe

                                            func ToECDSAUnsafe(d []byte) *ecdsa.PrivateKey

                                              ToECDSAUnsafe blindly converts a binary blob to a private key. It should almost never be used unless you are sure the input is valid and want to avoid hitting errors due to bad origin encoding (0 prefixes cut off).

                                              func UnmarshalPubkey

                                              func UnmarshalPubkey(pub []byte) (*ecdsa.PublicKey, error)

                                                UnmarshalPubkey converts bytes to a secp256k1 public key.

                                                func ValidateSignatureValues

                                                func ValidateSignatureValues(v byte, r, s *big.Int, homestead bool) bool

                                                  ValidateSignatureValues verifies whether the signature values are valid with the given chain rules. The v value is assumed to be either 0 or 1.

                                                  func VerifySignature

                                                  func VerifySignature(pubkey, digestHash, signature []byte) bool

                                                    VerifySignature checks that the given public key created signature over digest. The public key should be in compressed (33 bytes) or uncompressed (65 bytes) format. The signature should have the 64 byte [R || S] format.

                                                    Types

                                                    type KeccakState

                                                    type KeccakState interface {
                                                    	hash.Hash
                                                    	Read([]byte) (int, error)
                                                    }

                                                      KeccakState wraps sha3.state. In addition to the usual hash methods, it also supports Read to get a variable amount of data from the hash state. Read is faster than Sum because it doesn't copy the internal state, but also modifies the internal state.

                                                      func NewKeccakState

                                                      func NewKeccakState() KeccakState

                                                        NewKeccakState creates a new KeccakState

                                                        GOOS=linux, GOARCH=amd64

                                                        Directories

                                                        Path Synopsis
                                                        Package blake2b implements the BLAKE2b hash algorithm defined by RFC 7693 and the extendable output function (XOF) BLAKE2Xb.
                                                        Package blake2b implements the BLAKE2b hash algorithm defined by RFC 7693 and the extendable output function (XOF) BLAKE2Xb.
                                                        Package bn256 implements the Optimal Ate pairing over a 256-bit Barreto-Naehrig curve.
                                                        Package bn256 implements the Optimal Ate pairing over a 256-bit Barreto-Naehrig curve.
                                                        cloudflare
                                                        Package bn256 implements a particular bilinear group at the 128-bit security level.
                                                        Package bn256 implements a particular bilinear group at the 128-bit security level.
                                                        google
                                                        Package bn256 implements a particular bilinear group.
                                                        Package bn256 implements a particular bilinear group.
                                                        Package secp256k1 wraps the bitcoin secp256k1 C library.
                                                        Package secp256k1 wraps the bitcoin secp256k1 C library.