Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

curves

package

Go to main page

Versions in this module

v1

v1.8.0

Mar 11, 2022

Changes in this version

type Curve

+ func (c Curve) ToEllipticCurve() (elliptic.Curve, error)

+ type Koblitz256 struct

+ func K256Curve() *Koblitz256

+ func (curve *Koblitz256) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int)

+ func (curve *Koblitz256) Double(x1, y1 *big.Int) (*big.Int, *big.Int)

+ func (curve *Koblitz256) IsOnCurve(x, y *big.Int) bool

+ func (curve *Koblitz256) Params() *elliptic.CurveParams

+ func (curve *Koblitz256) ScalarBaseMult(k []byte) (*big.Int, *big.Int)

+ func (curve *Koblitz256) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.Int)

+ type NistP256 struct

+ func NistP256Curve() *NistP256

+ func (curve *NistP256) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int)

+ func (curve *NistP256) Double(x1, y1 *big.Int) (*big.Int, *big.Int)

+ func (curve *NistP256) IsOnCurve(x, y *big.Int) bool

+ func (curve *NistP256) Params() *elliptic.CurveParams

+ func (curve *NistP256) ScalarBaseMult(k []byte) (*big.Int, *big.Int)

+ func (curve *NistP256) ScalarMul(Bx, By *big.Int, k []byte) (*big.Int, *big.Int)

v1.5.5

Jan 31, 2022

v1.5.4

Dec 20, 2021

v1.5.3

Dec 14, 2021

v1.5.2

Dec 14, 2021

v1.5.1

Dec 6, 2021

Changes in this version

+ const BLS12377G1Name

+ const BLS12377G2Name

+ const BLS12377Name

+ const BLS12381G1Name

+ const BLS12381G2Name

+ const BLS12831Name

+ const ED25519Name

+ const K256Name

+ const P256Name

+ const PallasName

+ func Ed25519Order() *big.Int

+ func VerifyEcdsa(pk *EcPoint, hash []byte, sig *EcdsaSignature) bool

+ type Bls12381Scalar struct

+ func NewBls12381Scalar() *Bls12381Scalar

+ func (k Bls12381Scalar) Add(x, y *big.Int) *big.Int

+ func (k Bls12381Scalar) Bytes(x *big.Int) []byte

+ func (k Bls12381Scalar) Div(x, y *big.Int) *big.Int

+ func (k Bls12381Scalar) Hash(input []byte) *big.Int

+ func (k Bls12381Scalar) IsValid(x *big.Int) bool

+ func (k Bls12381Scalar) Mul(x, y *big.Int) *big.Int

+ func (k Bls12381Scalar) Neg(x *big.Int) *big.Int

+ func (k Bls12381Scalar) Random() (*big.Int, error)

+ func (k Bls12381Scalar) Sub(x, y *big.Int) *big.Int

+ type Curve struct

+ Name string

+ Point Point

+ Scalar Scalar

+ func BLS12377G1() *Curve

+ func BLS12377G2() *Curve

+ func BLS12381G1() *Curve

+ func BLS12381G2() *Curve

+ func ED25519() *Curve

+ func GetCurveByName(name string) *Curve

+ func K256() *Curve

+ func P256() *Curve

+ func PALLAS() *Curve

+ func (c Curve) NewGeneratorPoint() Point

+ func (c Curve) NewIdentityPoint() Point

+ func (c Curve) NewScalar() Scalar

+ func (c Curve) ScalarBaseMult(sc Scalar) Point

+ type EcPoint struct

+ Curve elliptic.Curve

+ X *big.Int

+ Y *big.Int

+ func NewScalarBaseMult(curve elliptic.Curve, k *big.Int) (*EcPoint, error)

+ func PointFromBytesUncompressed(curve elliptic.Curve, b []byte) (*EcPoint, error)

+ func (a *EcPoint) Add(b *EcPoint) (*EcPoint, error)

+ func (a *EcPoint) MarshalBinary() ([]byte, error)

+ func (a *EcPoint) Neg() (*EcPoint, error)

+ func (a *EcPoint) ScalarMult(k *big.Int) (*EcPoint, error)

+ func (a *EcPoint) UnmarshalBinary(data []byte) error

+ func (a *EcPoint) UnmarshalJSON(bytes []byte) error

+ func (a EcPoint) Bytes() []byte

+ func (a EcPoint) Equals(b *EcPoint) bool

+ func (a EcPoint) IsBasePoint() bool

+ func (a EcPoint) IsIdentity() bool

+ func (a EcPoint) IsOnCurve() bool

+ func (a EcPoint) IsValid() bool

+ func (a EcPoint) MarshalJSON() ([]byte, error)

+ type EcPointJson struct

+ CurveName string

+ X *big.Int

+ Y *big.Int

+ type EcScalar interface

+ Add func(x, y *big.Int) *big.Int

+ Bytes func(x *big.Int) []byte

+ Div func(x, y *big.Int) *big.Int

+ Hash func(input []byte) *big.Int

+ IsValid func(x *big.Int) bool

+ Mul func(x, y *big.Int) *big.Int

+ Neg func(x *big.Int) *big.Int

+ Random func() (*big.Int, error)

+ Sub func(x, y *big.Int) *big.Int

+ type EcdsaSignature struct

+ R *big.Int

+ S *big.Int

+ V int

+ type EcdsaVerify func(pubKey *EcPoint, hash []byte, signature *EcdsaSignature) bool

+ type Ed25519Scalar struct

+ func NewEd25519Scalar() *Ed25519Scalar

+ func (k Ed25519Scalar) Add(x, y *big.Int) *big.Int

+ func (k Ed25519Scalar) Bytes(x *big.Int) []byte

+ func (k Ed25519Scalar) Div(x, y *big.Int) *big.Int

+ func (k Ed25519Scalar) Hash(input []byte) *big.Int

+ func (k Ed25519Scalar) IsValid(x *big.Int) bool

+ func (k Ed25519Scalar) Mul(x, y *big.Int) *big.Int

+ func (k Ed25519Scalar) Neg(x *big.Int) *big.Int

+ func (k Ed25519Scalar) Random() (*big.Int, error)

+ func (k Ed25519Scalar) RandomWithReader(r io.Reader) (*big.Int, error)

+ func (k Ed25519Scalar) Sub(x, y *big.Int) *big.Int

+ type Element struct

+ Modulus *Field

+ Value *big.Int

+ func (x *Element) MarshalJSON() ([]byte, error)

+ func (x *Element) UnmarshalJSON(bytes []byte) error

+ func (x Element) Add(y *Element) *Element

+ func (x Element) BigInt() *big.Int

+ func (x Element) Bytes() []byte

+ func (x Element) Clone() *Element

+ func (x Element) Div(y *Element) *Element

+ func (x Element) Field() *Field

+ func (x Element) Invert() *Element

+ func (x Element) IsEqual(y *Element) bool

+ func (x Element) Mul(y *Element) *Element

+ func (x Element) Neg() *Element

+ func (x Element) Pow(y *Element) *Element

+ func (x Element) Sqrt() *Element

+ func (x Element) Sub(y *Element) *Element

+ type ElementJSON struct

+ Modulus string

+ Value string

+ type Ep struct

+ func (p *Ep) Add(lhs *Ep, rhs *Ep) *Ep

+ func (p *Ep) CMove(lhs, rhs *Ep, condition int) *Ep

+ func (p *Ep) Double(other *Ep) *Ep

+ func (p *Ep) Equal(other *Ep) bool

+ func (p *Ep) FromAffineCompressed(bytes []byte) (*Ep, error)

+ func (p *Ep) FromAffineUncompressed(bytes []byte) (*Ep, error)

+ func (p *Ep) Generator() *Ep

+ func (p *Ep) Hash(bytes []byte) *Ep

+ func (p *Ep) Identity() *Ep

+ func (p *Ep) IsIdentity() bool

+ func (p *Ep) IsOnCurve() bool

+ func (p *Ep) Mul(point *Ep, scalar *fq.Fq) *Ep

+ func (p *Ep) Neg(other *Ep) *Ep

+ func (p *Ep) Random(reader io.Reader) *Ep

+ func (p *Ep) Set(other *Ep) *Ep

+ func (p *Ep) Sub(lhs, rhs *Ep) *Ep

+ func (p *Ep) ToAffineCompressed() []byte

+ func (p *Ep) ToAffineUncompressed() []byte

+ func (p *Ep) X() *fp.Fp

+ func (p *Ep) Y() *fp.Fp

+ func (p Ep) CurveName() string

+ func (p Ep) SumOfProducts(points []*Ep, scalars []Scalar) *Ep

+ type Field struct

+ func NewField(modulus *big.Int) *Field

+ func (f Field) ElementFromBytes(bytes []byte) *Element

+ func (f Field) IsValid(value *big.Int) bool

+ func (f Field) NewElement(value *big.Int) *Element

+ func (f Field) One() *Element

+ func (f Field) RandomElement(r io.Reader) (*Element, error)

+ func (f Field) ReducedElementFromBytes(bytes []byte) *Element

+ func (f Field) Zero() *Element

+ type K256Scalar struct

+ func NewK256Scalar() *K256Scalar

+ func (k K256Scalar) Add(x, y *big.Int) *big.Int

+ func (k K256Scalar) Bytes(x *big.Int) []byte

+ func (k K256Scalar) Div(x, y *big.Int) *big.Int

+ func (k K256Scalar) Hash(input []byte) *big.Int

+ func (k K256Scalar) IsValid(x *big.Int) bool

+ func (k K256Scalar) Mul(x, y *big.Int) *big.Int

+ func (k K256Scalar) Neg(x *big.Int) *big.Int

+ func (k K256Scalar) Random() (*big.Int, error)

+ func (k K256Scalar) Sub(x, y *big.Int) *big.Int

+ type P256Scalar struct

+ func NewP256Scalar() *P256Scalar

+ func (k P256Scalar) Add(x, y *big.Int) *big.Int

+ func (k P256Scalar) Bytes(x *big.Int) []byte

+ func (k P256Scalar) Div(x, y *big.Int) *big.Int

+ func (k P256Scalar) Hash(input []byte) *big.Int

+ func (k P256Scalar) IsValid(x *big.Int) bool

+ func (k P256Scalar) Mul(x, y *big.Int) *big.Int

+ func (k P256Scalar) Neg(x *big.Int) *big.Int

+ func (k P256Scalar) Random() (*big.Int, error)

+ func (k P256Scalar) Sub(x, y *big.Int) *big.Int

+ type PairingCurve struct

+ GT Scalar

+ Name string

+ PointG1 PairingPoint

+ PointG2 PairingPoint

+ Scalar PairingScalar

+ func BLS12381(preferredPoint Point) *PairingCurve

+ func GetPairingCurveByName(name string) *PairingCurve

+ func (c PairingCurve) NewG1GeneratorPoint() PairingPoint

+ func (c PairingCurve) NewG1IdentityPoint() PairingPoint

+ func (c PairingCurve) NewG2GeneratorPoint() PairingPoint

+ func (c PairingCurve) NewG2IdentityPoint() PairingPoint

+ func (c PairingCurve) NewScalar() PairingScalar

+ func (c PairingCurve) ScalarG1BaseMult(sc Scalar) PairingPoint

+ func (c PairingCurve) ScalarG2BaseMult(sc Scalar) PairingPoint

+ type PairingPoint interface

+ MultiPairing func(...PairingPoint) Scalar

+ OtherGroup func() PairingPoint

+ Pairing func(rhs PairingPoint) Scalar

+ type PairingScalar interface

+ SetPoint func(p Point) PairingScalar

+ type PallasCurve struct

+ func Pallas() *PallasCurve

+ func (curve *PallasCurve) Add(x1, y1, x2, y2 *big.Int) (*big.Int, *big.Int)

+ func (curve *PallasCurve) Double(x1, y1 *big.Int) (*big.Int, *big.Int)

+ func (curve *PallasCurve) IsOnCurve(x, y *big.Int) bool

+ func (curve *PallasCurve) Params() *elliptic.CurveParams

+ func (curve *PallasCurve) ScalarBaseMult(k []byte) (*big.Int, *big.Int)

+ func (curve *PallasCurve) ScalarMult(Bx, By *big.Int, k []byte) (*big.Int, *big.Int)

+ type PallasScalar struct

+ func NewPallasScalar() *PallasScalar

+ func (k PallasScalar) Add(x, y *big.Int) *big.Int

+ func (k PallasScalar) Bytes(x *big.Int) []byte

+ func (k PallasScalar) Div(x, y *big.Int) *big.Int

+ func (k PallasScalar) Hash(input []byte) *big.Int

+ func (k PallasScalar) IsValid(x *big.Int) bool

+ func (k PallasScalar) Mul(x, y *big.Int) *big.Int

+ func (k PallasScalar) Neg(x *big.Int) *big.Int

+ func (k PallasScalar) Random() (*big.Int, error)

+ func (k PallasScalar) Sub(x, y *big.Int) *big.Int

+ type Point interface

+ Add func(rhs Point) Point

+ CurveName func() string

+ Double func() Point

+ Equal func(rhs Point) bool

+ FromAffineCompressed func(bytes []byte) (Point, error)

+ FromAffineUncompressed func(bytes []byte) (Point, error)

+ Generator func() Point

+ Hash func(bytes []byte) Point

+ Identity func() Point

+ IsIdentity func() bool

+ IsNegative func() bool

+ IsOnCurve func() bool

+ Mul func(rhs Scalar) Point

+ Neg func() Point

+ Random func(reader io.Reader) Point

+ Scalar func() Scalar

+ Set func(x, y *big.Int) (Point, error)

+ Sub func(rhs Point) Point

+ SumOfProducts func(points []Point, scalars []Scalar) Point

+ ToAffineCompressed func() []byte

+ ToAffineUncompressed func() []byte

+ type PointBls12377G1 struct

+ func (p *PointBls12377G1) Add(rhs Point) Point

+ func (p *PointBls12377G1) CurveName() string

+ func (p *PointBls12377G1) Double() Point

+ func (p *PointBls12377G1) Equal(rhs Point) bool

+ func (p *PointBls12377G1) FromAffineCompressed(bytes []byte) (Point, error)

+ func (p *PointBls12377G1) FromAffineUncompressed(bytes []byte) (Point, error)

+ func (p *PointBls12377G1) Generator() Point

+ func (p *PointBls12377G1) Hash(bytes []byte) Point

+ func (p *PointBls12377G1) Identity() Point

+ func (p *PointBls12377G1) IsIdentity() bool

+ func (p *PointBls12377G1) IsNegative() bool

+ func (p *PointBls12377G1) IsOnCurve() bool

+ func (p *PointBls12377G1) MarshalBinary() ([]byte, error)

+ func (p *PointBls12377G1) MarshalJSON() ([]byte, error)

+ func (p *PointBls12377G1) MarshalText() ([]byte, error)

+ func (p *PointBls12377G1) Modulus() *big.Int

+ func (p *PointBls12377G1) Mul(rhs Scalar) Point

+ func (p *PointBls12377G1) MultiPairing(points ...PairingPoint) Scalar

+ func (p *PointBls12377G1) Neg() Point

+ func (p *PointBls12377G1) OtherGroup() PairingPoint

+ func (p *PointBls12377G1) Pairing(rhs PairingPoint) Scalar

+ func (p *PointBls12377G1) Random(reader io.Reader) Point

+ func (p *PointBls12377G1) Scalar() Scalar

+ func (p *PointBls12377G1) Set(x, y *big.Int) (Point, error)

+ func (p *PointBls12377G1) Sub(rhs Point) Point

+ func (p *PointBls12377G1) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointBls12377G1) ToAffineCompressed() []byte

+ func (p *PointBls12377G1) ToAffineUncompressed() []byte

+ func (p *PointBls12377G1) UnmarshalBinary(input []byte) error

+ func (p *PointBls12377G1) UnmarshalJSON(input []byte) error

+ func (p *PointBls12377G1) UnmarshalText(input []byte) error

+ func (p *PointBls12377G1) X() *big.Int

+ func (p *PointBls12377G1) Y() *big.Int

+ type PointBls12377G2 struct

+ func (p *PointBls12377G2) Add(rhs Point) Point

+ func (p *PointBls12377G2) CurveName() string

+ func (p *PointBls12377G2) Double() Point

+ func (p *PointBls12377G2) Equal(rhs Point) bool

+ func (p *PointBls12377G2) FromAffineCompressed(bytes []byte) (Point, error)

+ func (p *PointBls12377G2) FromAffineUncompressed(bytes []byte) (Point, error)

+ func (p *PointBls12377G2) Generator() Point

+ func (p *PointBls12377G2) Hash(bytes []byte) Point

+ func (p *PointBls12377G2) Identity() Point

+ func (p *PointBls12377G2) IsIdentity() bool

+ func (p *PointBls12377G2) IsNegative() bool

+ func (p *PointBls12377G2) IsOnCurve() bool

+ func (p *PointBls12377G2) MarshalBinary() ([]byte, error)

+ func (p *PointBls12377G2) MarshalJSON() ([]byte, error)

+ func (p *PointBls12377G2) MarshalText() ([]byte, error)

+ func (p *PointBls12377G2) Modulus() *big.Int

+ func (p *PointBls12377G2) Mul(rhs Scalar) Point

+ func (p *PointBls12377G2) MultiPairing(points ...PairingPoint) Scalar

+ func (p *PointBls12377G2) Neg() Point

+ func (p *PointBls12377G2) OtherGroup() PairingPoint

+ func (p *PointBls12377G2) Pairing(rhs PairingPoint) Scalar

+ func (p *PointBls12377G2) Random(reader io.Reader) Point

+ func (p *PointBls12377G2) Scalar() Scalar

+ func (p *PointBls12377G2) Set(x, y *big.Int) (Point, error)

+ func (p *PointBls12377G2) Sub(rhs Point) Point

+ func (p *PointBls12377G2) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointBls12377G2) ToAffineCompressed() []byte

+ func (p *PointBls12377G2) ToAffineUncompressed() []byte

+ func (p *PointBls12377G2) UnmarshalBinary(input []byte) error

+ func (p *PointBls12377G2) UnmarshalJSON(input []byte) error

+ func (p *PointBls12377G2) UnmarshalText(input []byte) error

+ func (p *PointBls12377G2) X() *big.Int

+ func (p *PointBls12377G2) Y() *big.Int

+ type PointBls12381G1 struct

+ Value *bls12381.PointG1

+ func (p *PointBls12381G1) Add(rhs Point) Point

+ func (p *PointBls12381G1) CurveName() string

+ func (p *PointBls12381G1) Double() Point

+ func (p *PointBls12381G1) Equal(rhs Point) bool

+ func (p *PointBls12381G1) FromAffineCompressed(bytes []byte) (Point, error)

+ func (p *PointBls12381G1) FromAffineUncompressed(bytes []byte) (Point, error)

+ func (p *PointBls12381G1) Generator() Point

+ func (p *PointBls12381G1) Hash(bytes []byte) Point

+ func (p *PointBls12381G1) Identity() Point

+ func (p *PointBls12381G1) IsIdentity() bool

+ func (p *PointBls12381G1) IsNegative() bool

+ func (p *PointBls12381G1) IsOnCurve() bool

+ func (p *PointBls12381G1) MarshalBinary() ([]byte, error)

+ func (p *PointBls12381G1) MarshalJSON() ([]byte, error)

+ func (p *PointBls12381G1) MarshalText() ([]byte, error)

+ func (p *PointBls12381G1) Modulus() *big.Int

+ func (p *PointBls12381G1) Mul(rhs Scalar) Point

+ func (p *PointBls12381G1) MultiPairing(points ...PairingPoint) Scalar

+ func (p *PointBls12381G1) Neg() Point

+ func (p *PointBls12381G1) OtherGroup() PairingPoint

+ func (p *PointBls12381G1) Pairing(rhs PairingPoint) Scalar

+ func (p *PointBls12381G1) Random(reader io.Reader) Point

+ func (p *PointBls12381G1) Scalar() Scalar

+ func (p *PointBls12381G1) Set(x, y *big.Int) (Point, error)

+ func (p *PointBls12381G1) Sub(rhs Point) Point

+ func (p *PointBls12381G1) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointBls12381G1) ToAffineCompressed() []byte

+ func (p *PointBls12381G1) ToAffineUncompressed() []byte

+ func (p *PointBls12381G1) UnmarshalBinary(input []byte) error

+ func (p *PointBls12381G1) UnmarshalJSON(input []byte) error

+ func (p *PointBls12381G1) UnmarshalText(input []byte) error

+ func (p *PointBls12381G1) X() *big.Int

+ func (p *PointBls12381G1) Y() *big.Int

+ type PointBls12381G2 struct

+ Value *bls12381.PointG2

+ func (p *PointBls12381G2) Add(rhs Point) Point

+ func (p *PointBls12381G2) CurveName() string

+ func (p *PointBls12381G2) Double() Point

+ func (p *PointBls12381G2) Equal(rhs Point) bool

+ func (p *PointBls12381G2) FromAffineCompressed(bytes []byte) (Point, error)

+ func (p *PointBls12381G2) FromAffineUncompressed(bytes []byte) (Point, error)

+ func (p *PointBls12381G2) Generator() Point

+ func (p *PointBls12381G2) Hash(bytes []byte) Point

+ func (p *PointBls12381G2) Identity() Point

+ func (p *PointBls12381G2) IsIdentity() bool

+ func (p *PointBls12381G2) IsNegative() bool

+ func (p *PointBls12381G2) IsOnCurve() bool

+ func (p *PointBls12381G2) MarshalBinary() ([]byte, error)

+ func (p *PointBls12381G2) MarshalJSON() ([]byte, error)

+ func (p *PointBls12381G2) MarshalText() ([]byte, error)

+ func (p *PointBls12381G2) Modulus() *big.Int

+ func (p *PointBls12381G2) Mul(rhs Scalar) Point

+ func (p *PointBls12381G2) MultiPairing(points ...PairingPoint) Scalar

+ func (p *PointBls12381G2) Neg() Point

+ func (p *PointBls12381G2) OtherGroup() PairingPoint

+ func (p *PointBls12381G2) Pairing(rhs PairingPoint) Scalar

+ func (p *PointBls12381G2) Random(reader io.Reader) Point

+ func (p *PointBls12381G2) Scalar() Scalar

+ func (p *PointBls12381G2) Set(x, y *big.Int) (Point, error)

+ func (p *PointBls12381G2) Sub(rhs Point) Point

+ func (p *PointBls12381G2) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointBls12381G2) ToAffineCompressed() []byte

+ func (p *PointBls12381G2) ToAffineUncompressed() []byte

+ func (p *PointBls12381G2) UnmarshalBinary(input []byte) error

+ func (p *PointBls12381G2) UnmarshalJSON(input []byte) error

+ func (p *PointBls12381G2) UnmarshalText(input []byte) error

+ func (p *PointBls12381G2) X() *big.Int

+ func (p *PointBls12381G2) Y() *big.Int

+ type PointEd25519 struct

+ func (p *PointEd25519) Add(rhs Point) Point

+ func (p *PointEd25519) CurveName() string

+ func (p *PointEd25519) Double() Point

+ func (p *PointEd25519) Equal(rhs Point) bool

+ func (p *PointEd25519) FromAffineCompressed(inBytes []byte) (Point, error)

+ func (p *PointEd25519) FromAffineUncompressed(inBytes []byte) (Point, error)

+ func (p *PointEd25519) Generator() Point

+ func (p *PointEd25519) GetEdwardsPoint() *edwards25519.Point

+ func (p *PointEd25519) Hash(bytes []byte) Point

+ func (p *PointEd25519) Identity() Point

+ func (p *PointEd25519) IsIdentity() bool

+ func (p *PointEd25519) IsNegative() bool

+ func (p *PointEd25519) IsOnCurve() bool

+ func (p *PointEd25519) MangleScalarBitsAndMulByBasepointToProducePublicKey(rhs *ScalarEd25519) *PointEd25519

+ func (p *PointEd25519) MarshalBinary() ([]byte, error)

+ func (p *PointEd25519) MarshalJSON() ([]byte, error)

+ func (p *PointEd25519) MarshalText() ([]byte, error)

+ func (p *PointEd25519) Mul(rhs Scalar) Point

+ func (p *PointEd25519) Neg() Point

+ func (p *PointEd25519) Random(reader io.Reader) Point

+ func (p *PointEd25519) Scalar() Scalar

+ func (p *PointEd25519) Set(x, y *big.Int) (Point, error)

+ func (p *PointEd25519) SetEdwardsPoint(pt *edwards25519.Point) *PointEd25519

+ func (p *PointEd25519) Sub(rhs Point) Point

+ func (p *PointEd25519) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointEd25519) ToAffineCompressed() []byte

+ func (p *PointEd25519) ToAffineUncompressed() []byte

+ func (p *PointEd25519) UnmarshalBinary(input []byte) error

+ func (p *PointEd25519) UnmarshalJSON(input []byte) error

+ func (p *PointEd25519) UnmarshalText(input []byte) error

+ func (p *PointEd25519) VarTimeDoubleScalarBaseMult(a Scalar, A Point, b Scalar) Point

+ type PointK256 struct

+ func (p *PointK256) Add(rhs Point) Point

+ func (p *PointK256) CurveName() string

+ func (p *PointK256) Double() Point

+ func (p *PointK256) Equal(rhs Point) bool

+ func (p *PointK256) FromAffineCompressed(bytes []byte) (Point, error)

+ func (p *PointK256) FromAffineUncompressed(bytes []byte) (Point, error)

+ func (p *PointK256) Generator() Point

+ func (p *PointK256) Hash(bytes []byte) Point

+ func (p *PointK256) Identity() Point

+ func (p *PointK256) IsIdentity() bool

+ func (p *PointK256) IsNegative() bool

+ func (p *PointK256) IsOnCurve() bool

+ func (p *PointK256) MarshalBinary() ([]byte, error)

+ func (p *PointK256) MarshalJSON() ([]byte, error)

+ func (p *PointK256) MarshalText() ([]byte, error)

+ func (p *PointK256) Mul(rhs Scalar) Point

+ func (p *PointK256) Neg() Point

+ func (p *PointK256) Params() *elliptic.CurveParams

+ func (p *PointK256) Random(reader io.Reader) Point

+ func (p *PointK256) Scalar() Scalar

+ func (p *PointK256) Set(x, y *big.Int) (Point, error)

+ func (p *PointK256) Sub(rhs Point) Point

+ func (p *PointK256) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointK256) ToAffineCompressed() []byte

+ func (p *PointK256) ToAffineUncompressed() []byte

+ func (p *PointK256) UnmarshalBinary(input []byte) error

+ func (p *PointK256) UnmarshalJSON(input []byte) error

+ func (p *PointK256) UnmarshalText(input []byte) error

+ func (p *PointK256) X() *big.Int

+ func (p *PointK256) Y() *big.Int

+ type PointP256 struct

+ func (p *PointP256) Add(rhs Point) Point

+ func (p *PointP256) CurveName() string

+ func (p *PointP256) Double() Point

+ func (p *PointP256) Equal(rhs Point) bool

+ func (p *PointP256) FromAffineCompressed(bytes []byte) (Point, error)

+ func (p *PointP256) FromAffineUncompressed(bytes []byte) (Point, error)

+ func (p *PointP256) Generator() Point

+ func (p *PointP256) Hash(bytes []byte) Point

+ func (p *PointP256) Identity() Point

+ func (p *PointP256) IsIdentity() bool

+ func (p *PointP256) IsNegative() bool

+ func (p *PointP256) IsOnCurve() bool

+ func (p *PointP256) MarshalBinary() ([]byte, error)

+ func (p *PointP256) MarshalJSON() ([]byte, error)

+ func (p *PointP256) MarshalText() ([]byte, error)

+ func (p *PointP256) Mul(rhs Scalar) Point

+ func (p *PointP256) Neg() Point

+ func (p *PointP256) Params() *elliptic.CurveParams

+ func (p *PointP256) Random(reader io.Reader) Point

+ func (p *PointP256) Scalar() Scalar

+ func (p *PointP256) Set(x, y *big.Int) (Point, error)

+ func (p *PointP256) Sub(rhs Point) Point

+ func (p *PointP256) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointP256) ToAffineCompressed() []byte

+ func (p *PointP256) ToAffineUncompressed() []byte

+ func (p *PointP256) UnmarshalBinary(input []byte) error

+ func (p *PointP256) UnmarshalJSON(input []byte) error

+ func (p *PointP256) UnmarshalText(input []byte) error

+ func (p *PointP256) X() *big.Int

+ func (p *PointP256) Y() *big.Int

+ type PointPallas struct

+ func (p *PointPallas) Add(rhs Point) Point

+ func (p *PointPallas) CurveName() string

+ func (p *PointPallas) Double() Point

+ func (p *PointPallas) Equal(rhs Point) bool

+ func (p *PointPallas) FromAffineCompressed(bytes []byte) (Point, error)

+ func (p *PointPallas) FromAffineUncompressed(bytes []byte) (Point, error)

+ func (p *PointPallas) Generator() Point

+ func (p *PointPallas) GetEp() *Ep

+ func (p *PointPallas) Hash(bytes []byte) Point

+ func (p *PointPallas) Identity() Point

+ func (p *PointPallas) IsIdentity() bool

+ func (p *PointPallas) IsNegative() bool

+ func (p *PointPallas) IsOnCurve() bool

+ func (p *PointPallas) MarshalBinary() ([]byte, error)

+ func (p *PointPallas) MarshalJSON() ([]byte, error)

+ func (p *PointPallas) MarshalText() ([]byte, error)

+ func (p *PointPallas) Mul(rhs Scalar) Point

+ func (p *PointPallas) Neg() Point

+ func (p *PointPallas) Random(reader io.Reader) Point

+ func (p *PointPallas) Scalar() Scalar

+ func (p *PointPallas) Set(x, y *big.Int) (Point, error)

+ func (p *PointPallas) Sub(rhs Point) Point

+ func (p *PointPallas) SumOfProducts(points []Point, scalars []Scalar) Point

+ func (p *PointPallas) ToAffineCompressed() []byte

+ func (p *PointPallas) ToAffineUncompressed() []byte

+ func (p *PointPallas) UnmarshalBinary(input []byte) error

+ func (p *PointPallas) UnmarshalJSON(input []byte) error

+ func (p *PointPallas) UnmarshalText(input []byte) error

+ func (p *PointPallas) X() *fp.Fp

+ func (p *PointPallas) Y() *fp.Fp

+ type Scalar interface

+ Add func(rhs Scalar) Scalar

+ BigInt func() *big.Int

+ Bytes func() []byte

+ Clone func() Scalar

+ Cmp func(rhs Scalar) int

+ Cube func() Scalar

+ Div func(rhs Scalar) Scalar

+ Double func() Scalar

+ Hash func(bytes []byte) Scalar

+ Invert func() (Scalar, error)

+ IsEven func() bool

+ IsOdd func() bool

+ IsOne func() bool

+ IsZero func() bool

+ Mul func(rhs Scalar) Scalar

+ MulAdd func(y, z Scalar) Scalar

+ Neg func() Scalar

+ New func(value int) Scalar

+ One func() Scalar

+ Point func() Point

+ Random func(reader io.Reader) Scalar

+ SetBigInt func(v *big.Int) (Scalar, error)

+ SetBytes func(bytes []byte) (Scalar, error)

+ SetBytesWide func(bytes []byte) (Scalar, error)

+ Sqrt func() (Scalar, error)

+ Square func() Scalar

+ Sub func(rhs Scalar) Scalar

+ Zero func() Scalar

+ type ScalarBls12377 struct

+ func (s *ScalarBls12377) Add(rhs Scalar) Scalar

+ func (s *ScalarBls12377) BigInt() *big.Int

+ func (s *ScalarBls12377) Bytes() []byte

+ func (s *ScalarBls12377) Clone() Scalar

+ func (s *ScalarBls12377) Cmp(rhs Scalar) int

+ func (s *ScalarBls12377) Cube() Scalar

+ func (s *ScalarBls12377) Div(rhs Scalar) Scalar

+ func (s *ScalarBls12377) Double() Scalar

+ func (s *ScalarBls12377) Hash(bytes []byte) Scalar

+ func (s *ScalarBls12377) Invert() (Scalar, error)

+ func (s *ScalarBls12377) IsEven() bool

+ func (s *ScalarBls12377) IsOdd() bool

+ func (s *ScalarBls12377) IsOne() bool

+ func (s *ScalarBls12377) IsZero() bool

+ func (s *ScalarBls12377) MarshalBinary() ([]byte, error)

+ func (s *ScalarBls12377) MarshalJSON() ([]byte, error)

+ func (s *ScalarBls12377) MarshalText() ([]byte, error)

+ func (s *ScalarBls12377) Mul(rhs Scalar) Scalar

+ func (s *ScalarBls12377) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarBls12377) Neg() Scalar

+ func (s *ScalarBls12377) New(value int) Scalar

+ func (s *ScalarBls12377) One() Scalar

+ func (s *ScalarBls12377) Order() *big.Int

+ func (s *ScalarBls12377) Point() Point

+ func (s *ScalarBls12377) Random(reader io.Reader) Scalar

+ func (s *ScalarBls12377) SetBigInt(v *big.Int) (Scalar, error)

+ func (s *ScalarBls12377) SetBytes(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12377) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12377) SetPoint(p Point) PairingScalar

+ func (s *ScalarBls12377) Sqrt() (Scalar, error)

+ func (s *ScalarBls12377) Square() Scalar

+ func (s *ScalarBls12377) Sub(rhs Scalar) Scalar

+ func (s *ScalarBls12377) UnmarshalBinary(input []byte) error

+ func (s *ScalarBls12377) UnmarshalJSON(input []byte) error

+ func (s *ScalarBls12377) UnmarshalText(input []byte) error

+ func (s *ScalarBls12377) Zero() Scalar

+ type ScalarBls12377Gt struct

+ func (s *ScalarBls12377Gt) Add(rhs Scalar) Scalar

+ func (s *ScalarBls12377Gt) BigInt() *big.Int

+ func (s *ScalarBls12377Gt) Bytes() []byte

+ func (s *ScalarBls12377Gt) Clone() Scalar

+ func (s *ScalarBls12377Gt) Cmp(rhs Scalar) int

+ func (s *ScalarBls12377Gt) Cube() Scalar

+ func (s *ScalarBls12377Gt) Div(rhs Scalar) Scalar

+ func (s *ScalarBls12377Gt) Double() Scalar

+ func (s *ScalarBls12377Gt) Hash(bytes []byte) Scalar

+ func (s *ScalarBls12377Gt) Invert() (Scalar, error)

+ func (s *ScalarBls12377Gt) IsEven() bool

+ func (s *ScalarBls12377Gt) IsOdd() bool

+ func (s *ScalarBls12377Gt) IsOne() bool

+ func (s *ScalarBls12377Gt) IsZero() bool

+ func (s *ScalarBls12377Gt) MarshalBinary() ([]byte, error)

+ func (s *ScalarBls12377Gt) MarshalJSON() ([]byte, error)

+ func (s *ScalarBls12377Gt) MarshalText() ([]byte, error)

+ func (s *ScalarBls12377Gt) Mul(rhs Scalar) Scalar

+ func (s *ScalarBls12377Gt) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarBls12377Gt) Neg() Scalar

+ func (s *ScalarBls12377Gt) New(input int) Scalar

+ func (s *ScalarBls12377Gt) One() Scalar

+ func (s *ScalarBls12377Gt) Point() Point

+ func (s *ScalarBls12377Gt) Random(reader io.Reader) Scalar

+ func (s *ScalarBls12377Gt) SetBigInt(v *big.Int) (Scalar, error)

+ func (s *ScalarBls12377Gt) SetBytes(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12377Gt) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12377Gt) Sqrt() (Scalar, error)

+ func (s *ScalarBls12377Gt) Square() Scalar

+ func (s *ScalarBls12377Gt) Sub(rhs Scalar) Scalar

+ func (s *ScalarBls12377Gt) UnmarshalBinary(input []byte) error

+ func (s *ScalarBls12377Gt) UnmarshalJSON(input []byte) error

+ func (s *ScalarBls12377Gt) UnmarshalText(input []byte) error

+ func (s *ScalarBls12377Gt) Zero() Scalar

+ type ScalarBls12381 struct

+ Value *big.Int

+ func (s *ScalarBls12381) Add(rhs Scalar) Scalar

+ func (s *ScalarBls12381) BigInt() *big.Int

+ func (s *ScalarBls12381) Bytes() []byte

+ func (s *ScalarBls12381) Clone() Scalar

+ func (s *ScalarBls12381) Cmp(rhs Scalar) int

+ func (s *ScalarBls12381) Cube() Scalar

+ func (s *ScalarBls12381) Div(rhs Scalar) Scalar

+ func (s *ScalarBls12381) Double() Scalar

+ func (s *ScalarBls12381) Hash(bytes []byte) Scalar

+ func (s *ScalarBls12381) Invert() (Scalar, error)

+ func (s *ScalarBls12381) IsEven() bool

+ func (s *ScalarBls12381) IsOdd() bool

+ func (s *ScalarBls12381) IsOne() bool

+ func (s *ScalarBls12381) IsZero() bool

+ func (s *ScalarBls12381) MarshalBinary() ([]byte, error)

+ func (s *ScalarBls12381) MarshalJSON() ([]byte, error)

+ func (s *ScalarBls12381) MarshalText() ([]byte, error)

+ func (s *ScalarBls12381) Mul(rhs Scalar) Scalar

+ func (s *ScalarBls12381) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarBls12381) Neg() Scalar

+ func (s *ScalarBls12381) New(value int) Scalar

+ func (s *ScalarBls12381) One() Scalar

+ func (s *ScalarBls12381) Order() *big.Int

+ func (s *ScalarBls12381) Point() Point

+ func (s *ScalarBls12381) Random(reader io.Reader) Scalar

+ func (s *ScalarBls12381) SetBigInt(v *big.Int) (Scalar, error)

+ func (s *ScalarBls12381) SetBytes(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12381) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12381) SetPoint(p Point) PairingScalar

+ func (s *ScalarBls12381) Sqrt() (Scalar, error)

+ func (s *ScalarBls12381) Square() Scalar

+ func (s *ScalarBls12381) Sub(rhs Scalar) Scalar

+ func (s *ScalarBls12381) UnmarshalBinary(input []byte) error

+ func (s *ScalarBls12381) UnmarshalJSON(input []byte) error

+ func (s *ScalarBls12381) UnmarshalText(input []byte) error

+ func (s *ScalarBls12381) Zero() Scalar

+ type ScalarBls12381Gt struct

+ Value *bls12381.E

+ func (s *ScalarBls12381Gt) Add(rhs Scalar) Scalar

+ func (s *ScalarBls12381Gt) BigInt() *big.Int

+ func (s *ScalarBls12381Gt) Bytes() []byte

+ func (s *ScalarBls12381Gt) Clone() Scalar

+ func (s *ScalarBls12381Gt) Cmp(rhs Scalar) int

+ func (s *ScalarBls12381Gt) Cube() Scalar

+ func (s *ScalarBls12381Gt) Div(rhs Scalar) Scalar

+ func (s *ScalarBls12381Gt) Double() Scalar

+ func (s *ScalarBls12381Gt) Hash(bytes []byte) Scalar

+ func (s *ScalarBls12381Gt) Invert() (Scalar, error)

+ func (s *ScalarBls12381Gt) IsEven() bool

+ func (s *ScalarBls12381Gt) IsOdd() bool

+ func (s *ScalarBls12381Gt) IsOne() bool

+ func (s *ScalarBls12381Gt) IsZero() bool

+ func (s *ScalarBls12381Gt) MarshalBinary() ([]byte, error)

+ func (s *ScalarBls12381Gt) MarshalJSON() ([]byte, error)

+ func (s *ScalarBls12381Gt) MarshalText() ([]byte, error)

+ func (s *ScalarBls12381Gt) Mul(rhs Scalar) Scalar

+ func (s *ScalarBls12381Gt) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarBls12381Gt) Neg() Scalar

+ func (s *ScalarBls12381Gt) New(input int) Scalar

+ func (s *ScalarBls12381Gt) One() Scalar

+ func (s *ScalarBls12381Gt) Point() Point

+ func (s *ScalarBls12381Gt) Random(reader io.Reader) Scalar

+ func (s *ScalarBls12381Gt) SetBigInt(v *big.Int) (Scalar, error)

+ func (s *ScalarBls12381Gt) SetBytes(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12381Gt) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarBls12381Gt) Sqrt() (Scalar, error)

+ func (s *ScalarBls12381Gt) Square() Scalar

+ func (s *ScalarBls12381Gt) Sub(rhs Scalar) Scalar

+ func (s *ScalarBls12381Gt) UnmarshalBinary(input []byte) error

+ func (s *ScalarBls12381Gt) UnmarshalJSON(input []byte) error

+ func (s *ScalarBls12381Gt) UnmarshalText(input []byte) error

+ func (s *ScalarBls12381Gt) Zero() Scalar

+ type ScalarEd25519 struct

+ func (s *ScalarEd25519) Add(rhs Scalar) Scalar

+ func (s *ScalarEd25519) BigInt() *big.Int

+ func (s *ScalarEd25519) Bytes() []byte

+ func (s *ScalarEd25519) Clone() Scalar

+ func (s *ScalarEd25519) Cmp(rhs Scalar) int

+ func (s *ScalarEd25519) Cube() Scalar

+ func (s *ScalarEd25519) Div(rhs Scalar) Scalar

+ func (s *ScalarEd25519) Double() Scalar

+ func (s *ScalarEd25519) GetEdwardsScalar() *edwards25519.Scalar

+ func (s *ScalarEd25519) Hash(bytes []byte) Scalar

+ func (s *ScalarEd25519) Invert() (Scalar, error)

+ func (s *ScalarEd25519) IsEven() bool

+ func (s *ScalarEd25519) IsOdd() bool

+ func (s *ScalarEd25519) IsOne() bool

+ func (s *ScalarEd25519) IsZero() bool

+ func (s *ScalarEd25519) MarshalBinary() ([]byte, error)

+ func (s *ScalarEd25519) MarshalJSON() ([]byte, error)

+ func (s *ScalarEd25519) MarshalText() ([]byte, error)

+ func (s *ScalarEd25519) Mul(rhs Scalar) Scalar

+ func (s *ScalarEd25519) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarEd25519) Neg() Scalar

+ func (s *ScalarEd25519) New(input int) Scalar

+ func (s *ScalarEd25519) One() Scalar

+ func (s *ScalarEd25519) Point() Point

+ func (s *ScalarEd25519) Random(reader io.Reader) Scalar

+ func (s *ScalarEd25519) SetBigInt(x *big.Int) (Scalar, error)

+ func (s *ScalarEd25519) SetBytes(input []byte) (Scalar, error)

+ func (s *ScalarEd25519) SetBytesCanonical(bytes []byte) (Scalar, error)

+ func (s *ScalarEd25519) SetBytesClamping(bytes []byte) (Scalar, error)

+ func (s *ScalarEd25519) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarEd25519) SetEdwardsScalar(sc *edwards25519.Scalar) *ScalarEd25519

+ func (s *ScalarEd25519) Sqrt() (Scalar, error)

+ func (s *ScalarEd25519) Square() Scalar

+ func (s *ScalarEd25519) Sub(rhs Scalar) Scalar

+ func (s *ScalarEd25519) UnmarshalBinary(input []byte) error

+ func (s *ScalarEd25519) UnmarshalJSON(input []byte) error

+ func (s *ScalarEd25519) UnmarshalText(input []byte) error

+ func (s *ScalarEd25519) Zero() Scalar

+ type ScalarK256 struct

+ func (s *ScalarK256) Add(rhs Scalar) Scalar

+ func (s *ScalarK256) BigInt() *big.Int

+ func (s *ScalarK256) Bytes() []byte

+ func (s *ScalarK256) Clone() Scalar

+ func (s *ScalarK256) Cmp(rhs Scalar) int

+ func (s *ScalarK256) Cube() Scalar

+ func (s *ScalarK256) Div(rhs Scalar) Scalar

+ func (s *ScalarK256) Double() Scalar

+ func (s *ScalarK256) Hash(bytes []byte) Scalar

+ func (s *ScalarK256) Invert() (Scalar, error)

+ func (s *ScalarK256) IsEven() bool

+ func (s *ScalarK256) IsOdd() bool

+ func (s *ScalarK256) IsOne() bool

+ func (s *ScalarK256) IsZero() bool

+ func (s *ScalarK256) MarshalBinary() ([]byte, error)

+ func (s *ScalarK256) MarshalJSON() ([]byte, error)

+ func (s *ScalarK256) MarshalText() ([]byte, error)

+ func (s *ScalarK256) Mul(rhs Scalar) Scalar

+ func (s *ScalarK256) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarK256) Neg() Scalar

+ func (s *ScalarK256) New(value int) Scalar

+ func (s *ScalarK256) One() Scalar

+ func (s *ScalarK256) Point() Point

+ func (s *ScalarK256) Random(reader io.Reader) Scalar

+ func (s *ScalarK256) SetBigInt(v *big.Int) (Scalar, error)

+ func (s *ScalarK256) SetBytes(bytes []byte) (Scalar, error)

+ func (s *ScalarK256) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarK256) Sqrt() (Scalar, error)

+ func (s *ScalarK256) Square() Scalar

+ func (s *ScalarK256) Sub(rhs Scalar) Scalar

+ func (s *ScalarK256) UnmarshalBinary(input []byte) error

+ func (s *ScalarK256) UnmarshalJSON(input []byte) error

+ func (s *ScalarK256) UnmarshalText(input []byte) error

+ func (s *ScalarK256) Zero() Scalar

+ type ScalarP256 struct

+ func (s *ScalarP256) Add(rhs Scalar) Scalar

+ func (s *ScalarP256) BigInt() *big.Int

+ func (s *ScalarP256) Bytes() []byte

+ func (s *ScalarP256) Clone() Scalar

+ func (s *ScalarP256) Cmp(rhs Scalar) int

+ func (s *ScalarP256) Cube() Scalar

+ func (s *ScalarP256) Div(rhs Scalar) Scalar

+ func (s *ScalarP256) Double() Scalar

+ func (s *ScalarP256) Hash(bytes []byte) Scalar

+ func (s *ScalarP256) Invert() (Scalar, error)

+ func (s *ScalarP256) IsEven() bool

+ func (s *ScalarP256) IsOdd() bool

+ func (s *ScalarP256) IsOne() bool

+ func (s *ScalarP256) IsZero() bool

+ func (s *ScalarP256) MarshalBinary() ([]byte, error)

+ func (s *ScalarP256) MarshalJSON() ([]byte, error)

+ func (s *ScalarP256) MarshalText() ([]byte, error)

+ func (s *ScalarP256) Mul(rhs Scalar) Scalar

+ func (s *ScalarP256) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarP256) Neg() Scalar

+ func (s *ScalarP256) New(value int) Scalar

+ func (s *ScalarP256) One() Scalar

+ func (s *ScalarP256) Point() Point

+ func (s *ScalarP256) Random(reader io.Reader) Scalar

+ func (s *ScalarP256) SetBigInt(v *big.Int) (Scalar, error)

+ func (s *ScalarP256) SetBytes(bytes []byte) (Scalar, error)

+ func (s *ScalarP256) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarP256) Sqrt() (Scalar, error)

+ func (s *ScalarP256) Square() Scalar

+ func (s *ScalarP256) Sub(rhs Scalar) Scalar

+ func (s *ScalarP256) UnmarshalBinary(input []byte) error

+ func (s *ScalarP256) UnmarshalJSON(input []byte) error

+ func (s *ScalarP256) UnmarshalText(input []byte) error

+ func (s *ScalarP256) Zero() Scalar

+ type ScalarPallas struct

+ func (s *ScalarPallas) Add(rhs Scalar) Scalar

+ func (s *ScalarPallas) BigInt() *big.Int

+ func (s *ScalarPallas) Bytes() []byte

+ func (s *ScalarPallas) Clone() Scalar

+ func (s *ScalarPallas) Cmp(rhs Scalar) int

+ func (s *ScalarPallas) Cube() Scalar

+ func (s *ScalarPallas) Div(rhs Scalar) Scalar

+ func (s *ScalarPallas) Double() Scalar

+ func (s *ScalarPallas) GetFq() *fq.Fq

+ func (s *ScalarPallas) Hash(bytes []byte) Scalar

+ func (s *ScalarPallas) Invert() (Scalar, error)

+ func (s *ScalarPallas) IsEven() bool

+ func (s *ScalarPallas) IsOdd() bool

+ func (s *ScalarPallas) IsOne() bool

+ func (s *ScalarPallas) IsZero() bool

+ func (s *ScalarPallas) MarshalBinary() ([]byte, error)

+ func (s *ScalarPallas) MarshalJSON() ([]byte, error)

+ func (s *ScalarPallas) MarshalText() ([]byte, error)

+ func (s *ScalarPallas) Mul(rhs Scalar) Scalar

+ func (s *ScalarPallas) MulAdd(y, z Scalar) Scalar

+ func (s *ScalarPallas) Neg() Scalar

+ func (s *ScalarPallas) New(value int) Scalar

+ func (s *ScalarPallas) One() Scalar

+ func (s *ScalarPallas) Point() Point

+ func (s *ScalarPallas) Random(reader io.Reader) Scalar

+ func (s *ScalarPallas) SetBigInt(v *big.Int) (Scalar, error)

+ func (s *ScalarPallas) SetBytes(bytes []byte) (Scalar, error)

+ func (s *ScalarPallas) SetBytesWide(bytes []byte) (Scalar, error)

+ func (s *ScalarPallas) SetFq(fq *fq.Fq) *ScalarPallas

+ func (s *ScalarPallas) Sqrt() (Scalar, error)

+ func (s *ScalarPallas) Square() Scalar

+ func (s *ScalarPallas) Sub(rhs Scalar) Scalar

+ func (s *ScalarPallas) UnmarshalBinary(input []byte) error

+ func (s *ScalarPallas) UnmarshalJSON(input []byte) error

+ func (s *ScalarPallas) UnmarshalText(input []byte) error

+ func (s *ScalarPallas) Zero() Scalar