SYMBOL INDEX (341 symbols across 19 files)

FILE: benches/public_key.rs
  function bench_public_key_parse (line 10) | fn bench_public_key_parse(b: &mut Bencher) {
  function bench_public_key_serialize (line 23) | fn bench_public_key_serialize(b: &mut Bencher) {
  function bench_public_key_serialize_compressed (line 37) | fn bench_public_key_serialize_compressed(b: &mut Bencher) {

FILE: benches/sign.rs
  function bench_sign_message (line 11) | fn bench_sign_message(b: &mut Bencher) {

FILE: benches/signature.rs
  function bench_signature_parse (line 10) | fn bench_signature_parse(b: &mut Bencher) {
  function bench_signature_serialize (line 27) | fn bench_signature_serialize(b: &mut Bencher) {

FILE: build.rs
  function main (line 3) | fn main() {

FILE: core/src/der.rs
  type SignatureArray (line 8) | pub struct SignatureArray([u8; 6 + 33 + 33], usize);
    method new (line 11) | pub fn new(size: usize) -> Self {
    method len (line 15) | pub fn len(&self) -> usize {
    method is_empty (line 19) | pub fn is_empty(&self) -> bool {
    method as_ref (line 25) | fn as_ref(&self) -> &[u8] {
    method as_mut (line 31) | fn as_mut(&mut self) -> &mut [u8] {
  type Decoder (line 36) | pub struct Decoder<'a>(&'a [u8], usize);
  function new (line 39) | pub fn new(arr: &'a [u8]) -> Self {
  function remaining_len (line 43) | pub fn remaining_len(&self) -> usize {
  function read (line 47) | pub fn read(&mut self) -> Result<u8, Error> {
  function peek (line 57) | pub fn peek(&self, forward: usize) -> Result<u8, Error> {
  function peek_slice (line 66) | pub fn peek_slice(&self, len: usize) -> Result<&[u8], Error> {
  function skip (line 75) | pub fn skip(&mut self, len: usize) -> Result<(), Error> {
  function read_constructed_sequence (line 84) | pub fn read_constructed_sequence(&mut self) -> Result<(), Error> {
  function read_len (line 93) | pub fn read_len(&mut self) -> Result<usize, Error> {
  function read_integer (line 140) | pub fn read_integer(&mut self) -> Result<Scalar, Error> {
  function read_seq_len_lax (line 190) | pub fn read_seq_len_lax(&mut self) -> Result<usize, Error> {
  function read_len_lax (line 203) | pub fn read_len_lax(&mut self) -> Result<usize, Error> {
  function read_integer_lax (line 232) | pub fn read_integer_lax(&mut self) -> Result<Scalar, Error> {

FILE: core/src/ecdh.rs
  method ecdh_raw (line 9) | pub fn ecdh_raw<D: Digest + Default>(

FILE: core/src/ecdsa.rs
  constant P_MINUS_ORDER (line 9) | const P_MINUS_ORDER: Field = Field::new(0, 0, 0, 1, 0x45512319, 0x50B75F...
  constant ORDER_AS_FE (line 11) | const ORDER_AS_FE: Field = Field::new(
  method verify_raw (line 16) | pub fn verify_raw(
  method recover_raw (line 58) | pub fn recover_raw(
  method sign_raw (line 107) | pub fn sign_raw(

FILE: core/src/ecmult.rs
  constant WINDOW_A (line 14) | pub const WINDOW_A: usize = 5;
  constant WINDOW_G (line 15) | pub const WINDOW_G: usize = 16;
  constant ECMULT_TABLE_SIZE_A (line 16) | pub const ECMULT_TABLE_SIZE_A: usize = 1 << (WINDOW_A - 2);
  constant ECMULT_TABLE_SIZE_G (line 17) | pub const ECMULT_TABLE_SIZE_G: usize = 1 << (WINDOW_G - 2);
  constant WNAF_BITS (line 18) | pub const WNAF_BITS: usize = 256;
  function odd_multiples_table_storage_var (line 20) | fn odd_multiples_table_storage_var(pre: &mut [AffineStorage], a: &Jacobi...
  type ECMultContext (line 43) | pub struct ECMultContext {
    method new_from_raw (line 54) | pub const unsafe fn new_from_raw(pre_g: [AffineStorage; ECMULT_TABLE_S...
    method inspect_raw (line 59) | pub fn inspect_raw(&self) -> &[AffineStorage; ECMULT_TABLE_SIZE_G] {
    method new_boxed (line 64) | pub fn new_boxed() -> Box<Self> {
    method ecmult (line 454) | pub fn ecmult(&self, r: &mut Jacobian, a: &Jacobian, na: &Scalar, ng: ...
    method ecmult_const (line 491) | pub fn ecmult_const(&self, r: &mut Jacobian, a: &Affine, scalar: &Scal...
  function set_all_gej_var (line 90) | pub fn set_all_gej_var(a: &[Jacobian]) -> Vec<Affine> {
  function inv_all_var (line 116) | pub fn inv_all_var(fields: &[Field]) -> Vec<Field> {
  constant GEN_BLIND (line 142) | const GEN_BLIND: Scalar = Scalar([
  constant GEN_INITIAL (line 145) | const GEN_INITIAL: Jacobian = Jacobian {
  type ECMultGenContext (line 162) | pub struct ECMultGenContext {
    method new_from_raw (line 175) | pub const unsafe fn new_from_raw(prec: [[AffineStorage; 16]; 64]) -> S...
    method inspect_raw (line 184) | pub fn inspect_raw(&self) -> &[[AffineStorage; 16]; 64] {
    method new_boxed (line 189) | pub fn new_boxed() -> Box<Self> {
    method ecmult_gen (line 560) | pub fn ecmult_gen(&self, r: &mut Jacobian, gn: &Scalar) {
  function odd_multiples_table (line 261) | pub fn odd_multiples_table(prej: &mut [Jacobian], zr: &mut [Field], a: &...
  function odd_multiples_table_globalz_windowa (line 289) | fn odd_multiples_table_globalz_windowa(
  function table_get_ge (line 301) | fn table_get_ge(r: &mut Affine, pre: &[Affine], n: i32, w: usize) {
  function table_get_ge_const (line 312) | fn table_get_ge_const(r: &mut Affine, pre: &[Affine], n: i32, w: usize) {
  function table_get_ge_storage (line 328) | fn table_get_ge_storage(r: &mut Affine, pre: &[AffineStorage], n: i32, w...
  function ecmult_wnaf (line 340) | pub fn ecmult_wnaf(wnaf: &mut [i32], a: &Scalar, w: usize) -> i32 {
  function ecmult_wnaf_const (line 394) | pub fn ecmult_wnaf_const(wnaf: &mut [i32], a: &Scalar, w: usize) -> i32 {

FILE: core/src/error.rs
  type Error (line 2) | pub enum Error {
    method fmt (line 17) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {

FILE: core/src/field.rs
  type Field (line 14) | pub struct Field {
    method new_raw (line 26) | pub const fn new_raw(
    method new (line 45) | pub const fn new(
    method from_int (line 73) | pub fn from_int(a: u32) -> Field {
    method verify (line 79) | fn verify(&self) -> bool {
    method normalize (line 112) | pub fn normalize(&mut self) {
    method normalize_weak (line 200) | pub fn normalize_weak(&mut self) {
    method normalize_var (line 244) | pub fn normalize_var(&mut self) {
    method normalizes_to_zero (line 336) | pub fn normalizes_to_zero(&self) -> bool {
    method normalizes_to_zero_var (line 404) | pub fn normalizes_to_zero_var(&self) -> bool {
    method set_int (line 487) | pub fn set_int(&mut self, a: u32) {
    method is_zero (line 496) | pub fn is_zero(&self) -> bool {
    method is_odd (line 514) | pub fn is_odd(&self) -> bool {
    method clear (line 521) | pub fn clear(&mut self) {
    method set_b32 (line 530) | pub fn set_b32(&mut self, a: &[u8; 32]) -> bool {
    method fill_b32 (line 584) | pub fn fill_b32(&self, r: &mut [u8; 32]) {
    method b32 (line 624) | pub fn b32(&self) -> [u8; 32] {
    method neg_in_place (line 633) | pub fn neg_in_place(&mut self, other: &Field, m: u32) {
    method neg (line 655) | pub fn neg(&self, m: u32) -> Field {
    method mul_int (line 663) | pub fn mul_int(&mut self, a: u32) {
    method cmp_var (line 682) | pub fn cmp_var(&self, other: &Field) -> Ordering {
    method eq_var (line 700) | pub fn eq_var(&self, other: &Field) -> bool {
    method mul_inner (line 706) | fn mul_inner(&mut self, a: &Field, b: &Field) {
    method sqr_inner (line 1097) | fn sqr_inner(&mut self, a: &Field) {
    method mul_in_place (line 1431) | pub fn mul_in_place(&mut self, a: &Field, b: &Field) {
    method sqr_in_place (line 1445) | pub fn sqr_in_place(&mut self, a: &Field) {
    method sqr (line 1454) | pub fn sqr(&self) -> Field {
    method sqrt (line 1466) | pub fn sqrt(&self) -> (Field, bool) {
    method inv (line 1546) | pub fn inv(&self) -> Field {
    method inv_var (line 1628) | pub fn inv_var(&self) -> Field {
    method is_quad_var (line 1633) | pub fn is_quad_var(&self) -> bool {
    method cmov (line 1640) | pub fn cmov(&mut self, other: &Field, flag: bool) {
    type Output (line 1675) | type Output = Field;
    method add (line 1676) | fn add(self, other: Field) -> Field {
    method add_assign (line 1693) | fn add_assign(&mut self, other: &'a Field) {
    method add_assign (line 1712) | fn add_assign(&mut self, other: Field) {
    type Output (line 1718) | type Output = Field;
    method mul (line 1719) | fn mul(self, other: Field) -> Field {
    method mul_assign (line 1736) | fn mul_assign(&mut self, other: &'a Field) {
    method mul_assign (line 1744) | fn mul_assign(&mut self, other: Field) {
    method from (line 1808) | fn from(a: FieldStorage) -> Field {
    method into (line 1830) | fn into(self) -> FieldStorage {
  method default (line 1665) | fn default() -> Field {
  type Output (line 1684) | type Output = Field;
  function add (line 1685) | fn add(self, other: &'a Field) -> Field {
  type Output (line 1727) | type Output = Field;
  function mul (line 1728) | fn mul(self, other: &'a Field) -> Field {
  method eq (line 1750) | fn eq(&self, other: &Field) -> bool {
  method cmp (line 1760) | fn cmp(&self, other: &Field) -> Ordering {
  method partial_cmp (line 1766) | fn partial_cmp(&self, other: &Field) -> Option<Ordering> {
  type FieldStorage (line 1773) | pub struct FieldStorage(pub [u32; 8]);
    method new (line 1782) | pub const fn new(
    method cmov (line 1795) | pub fn cmov(&mut self, other: &FieldStorage, flag: bool) {
  method default (line 1776) | fn default() -> FieldStorage {

FILE: core/src/group.rs
  type Affine (line 5) | pub struct Affine {
    method new (line 85) | pub const fn new(x: Field, y: Field) -> Self {
    method set_xy (line 95) | pub fn set_xy(&mut self, x: &Field, y: &Field) {
    method set_xquad (line 105) | pub fn set_xquad(&mut self, x: &Field) -> bool {
    method set_xo_var (line 121) | pub fn set_xo_var(&mut self, x: &Field, odd: bool) -> bool {
    method is_infinity (line 133) | pub fn is_infinity(&self) -> bool {
    method is_valid_var (line 138) | pub fn is_valid_var(&self) -> bool {
    method neg_in_place (line 152) | pub fn neg_in_place(&mut self, other: &Affine) {
    method neg (line 158) | pub fn neg(&self) -> Affine {
    method set_gej (line 166) | pub fn set_gej(&mut self, a: &Jacobian) {
    method from_gej (line 179) | pub fn from_gej(a: &Jacobian) -> Self {
    method set_gej_var (line 185) | pub fn set_gej_var(&mut self, a: &Jacobian) {
    method set_gej_zinv (line 201) | pub fn set_gej_zinv(&mut self, a: &Jacobian, zi: &Field) {
    method clear (line 210) | pub fn clear(&mut self) {
    method from (line 687) | fn from(a: AffineStorage) -> Affine {
    method into (line 693) | fn into(mut self) -> AffineStorage {
  type Jacobian (line 13) | pub struct Jacobian {
    method new (line 260) | pub const fn new(x: Field, y: Field) -> Self {
    method set_infinity (line 270) | pub fn set_infinity(&mut self) {
    method set_ge (line 279) | pub fn set_ge(&mut self, a: &Affine) {
    method from_ge (line 286) | pub fn from_ge(a: &Affine) -> Self {
    method eq_x_var (line 293) | pub fn eq_x_var(&self, x: &Field) -> bool {
    method neg_in_place (line 304) | pub fn neg_in_place(&mut self, a: &Jacobian) {
    method neg (line 313) | pub fn neg(&self) -> Jacobian {
    method is_infinity (line 320) | pub fn is_infinity(&self) -> bool {
    method has_quad_y_var (line 325) | pub fn has_quad_y_var(&self) -> bool {
    method double_nonzero_in_place (line 337) | pub fn double_nonzero_in_place(&mut self, a: &Jacobian, rzr: Option<&m...
    method double_var_in_place (line 344) | pub fn double_var_in_place(&mut self, a: &Jacobian, rzr: Option<&mut F...
    method double_var (line 381) | pub fn double_var(&self, rzr: Option<&mut Field>) -> Jacobian {
    method add_var_in_place (line 389) | pub fn add_var_in_place(&mut self, a: &Jacobian, b: &Jacobian, rzr: Op...
    method add_var (line 449) | pub fn add_var(&self, b: &Jacobian, rzr: Option<&mut Field>) -> Jacobi...
    method add_ge_in_place (line 457) | pub fn add_ge_in_place(&mut self, a: &Jacobian, b: &Affine) {
    method add_ge (line 524) | pub fn add_ge(&self, b: &Affine) -> Jacobian {
    method add_ge_var_in_place (line 536) | pub fn add_ge_var_in_place(&mut self, a: &Jacobian, b: &Affine, rzr: O...
    method add_ge_var (line 595) | pub fn add_ge_var(&self, b: &Affine, rzr: Option<&mut Field>) -> Jacob...
    method add_zinv_var_in_place (line 603) | pub fn add_zinv_var_in_place(&mut self, a: &Jacobian, b: &Affine, bzin...
    method add_zinv_var (line 659) | pub fn add_zinv_var(&mut self, b: &Affine, bzinv: &Field) -> Jacobian {
    method clear (line 667) | pub fn clear(&mut self) {
    method rescale (line 676) | pub fn rescale(&mut self, s: &Field) {
  type AffineStorage (line 22) | pub struct AffineStorage {
    method new (line 703) | pub const fn new(x: FieldStorage, y: FieldStorage) -> Self {
    method cmov (line 709) | pub fn cmov(&mut self, a: &AffineStorage, flag: bool) {
  method default (line 28) | fn default() -> Affine {
  method default (line 38) | fn default() -> Jacobian {
  method default (line 49) | fn default() -> AffineStorage {
  constant CURVE_B (line 81) | pub const CURVE_B: u32 = 7;
  function set_table_gej_var (line 217) | pub fn set_table_gej_var(r: &mut [Affine], a: &[Jacobian], zr: &[Field]) {
  function globalz_set_table_gej (line 235) | pub fn globalz_set_table_gej(r: &mut [Affine], globalz: &mut Field, a: &...

FILE: core/src/lib.rs
  constant TAG_PUBKEY_EVEN (line 51) | pub const TAG_PUBKEY_EVEN: u8 = 0x02;
  constant TAG_PUBKEY_ODD (line 52) | pub const TAG_PUBKEY_ODD: u8 = 0x03;
  constant TAG_PUBKEY_FULL (line 53) | pub const TAG_PUBKEY_FULL: u8 = 0x04;
  constant TAG_PUBKEY_HYBRID_EVEN (line 54) | pub const TAG_PUBKEY_HYBRID_EVEN: u8 = 0x06;
  constant TAG_PUBKEY_HYBRID_ODD (line 55) | pub const TAG_PUBKEY_HYBRID_ODD: u8 = 0x07;
  constant MESSAGE_SIZE (line 57) | pub const MESSAGE_SIZE: usize = 32;
  constant SECRET_KEY_SIZE (line 58) | pub const SECRET_KEY_SIZE: usize = 32;
  constant RAW_PUBLIC_KEY_SIZE (line 59) | pub const RAW_PUBLIC_KEY_SIZE: usize = 64;
  constant FULL_PUBLIC_KEY_SIZE (line 60) | pub const FULL_PUBLIC_KEY_SIZE: usize = 65;
  constant COMPRESSED_PUBLIC_KEY_SIZE (line 61) | pub const COMPRESSED_PUBLIC_KEY_SIZE: usize = 33;
  constant SIGNATURE_SIZE (line 62) | pub const SIGNATURE_SIZE: usize = 64;
  constant DER_MAX_SIGNATURE_SIZE (line 63) | pub const DER_MAX_SIGNATURE_SIZE: usize = 72;

FILE: core/src/scalar.rs
  constant SECP256K1_N (line 5) | const SECP256K1_N: [u32; 8] = [
  constant SECP256K1_N_C_0 (line 9) | const SECP256K1_N_C_0: u32 = !SECP256K1_N[0] + 1;
  constant SECP256K1_N_C_1 (line 10) | const SECP256K1_N_C_1: u32 = !SECP256K1_N[1];
  constant SECP256K1_N_C_2 (line 11) | const SECP256K1_N_C_2: u32 = !SECP256K1_N[2];
  constant SECP256K1_N_C_3 (line 12) | const SECP256K1_N_C_3: u32 = !SECP256K1_N[3];
  constant SECP256K1_N_C_4 (line 13) | const SECP256K1_N_C_4: u32 = 1;
  constant SECP256K1_N_H_0 (line 15) | const SECP256K1_N_H_0: u32 = 0x681B20A0;
  constant SECP256K1_N_H_1 (line 16) | const SECP256K1_N_H_1: u32 = 0xDFE92F46;
  constant SECP256K1_N_H_2 (line 17) | const SECP256K1_N_H_2: u32 = 0x57A4501D;
  constant SECP256K1_N_H_3 (line 18) | const SECP256K1_N_H_3: u32 = 0x5D576E73;
  constant SECP256K1_N_H_4 (line 19) | const SECP256K1_N_H_4: u32 = 0xFFFFFFFF;
  constant SECP256K1_N_H_5 (line 20) | const SECP256K1_N_H_5: u32 = 0xFFFFFFFF;
  constant SECP256K1_N_H_6 (line 21) | const SECP256K1_N_H_6: u32 = 0xFFFFFFFF;
  constant SECP256K1_N_H_7 (line 22) | const SECP256K1_N_H_7: u32 = 0x7FFFFFFF;
  type Scalar (line 26) | pub struct Scalar(pub [u32; 8]);
    method clear (line 30) | pub fn clear(&mut self) {
    method set_int (line 37) | pub fn set_int(&mut self, v: u32) {
    method from_int (line 42) | pub fn from_int(v: u32) -> Self {
    method bits (line 50) | pub fn bits(&self, offset: usize, count: usize) -> u32 {
    method bits_var (line 56) | pub fn bits_var(&self, offset: usize, count: usize) -> u32 {
    method check_overflow (line 70) | fn check_overflow(&self) -> Choice {
    method reduce (line 89) | fn reduce(&mut self, overflow: Choice) {
    method cadd_bit (line 127) | pub fn cadd_bit(&mut self, mut bit: usize, flag: bool) {
    method set_b32 (line 160) | pub fn set_b32(&mut self, b32: &[u8; 32]) -> Choice {
    method b32 (line 201) | pub fn b32(&self) -> [u8; 32] {
    method fill_b32 (line 208) | pub fn fill_b32(&self, bin: &mut [u8; 32]) {
    method is_zero (line 244) | pub fn is_zero(&self) -> bool {
    method is_one (line 257) | pub fn is_one(&self) -> bool {
    method is_high (line 271) | pub fn is_high(&self) -> bool {
    method cond_neg_assign (line 290) | pub fn cond_neg_assign(&mut self, flag: Choice) {
    method reduce_512 (line 417) | fn reduce_512(&mut self, l: &[u32; 16]) {
    method mul_512 (line 584) | fn mul_512(&self, b: &Scalar, l: &mut [u32; 16]) {
    method sqr_512 (line 672) | fn sqr_512(&self, l: &mut [u32; 16]) {
    method mul_in_place (line 732) | pub fn mul_in_place(&mut self, a: &Scalar, b: &Scalar) {
    method shr_int (line 740) | pub fn shr_int(&mut self, n: usize) -> u32 {
    method sqr_in_place (line 756) | pub fn sqr_in_place(&mut self, a: &Scalar) {
    method sqr (line 762) | pub fn sqr(&self) -> Scalar {
    method inv_in_place (line 768) | pub fn inv_in_place(&mut self, x: &Scalar) {
    method inv (line 914) | pub fn inv(&self) -> Scalar {
    method inv_var (line 920) | pub fn inv_var(&self) -> Scalar {
    method is_even (line 924) | pub fn is_even(&self) -> bool {
    type Output (line 936) | type Output = Scalar;
    method add (line 937) | fn add(mut self, other: Scalar) -> Scalar {
    method add_assign (line 953) | fn add_assign(&mut self, other: &'a Scalar) {
    method add_assign (line 970) | fn add_assign(&mut self, other: Scalar) {
    type Output (line 976) | type Output = Scalar;
    method mul (line 977) | fn mul(self, other: Scalar) -> Scalar {
    method mul_assign (line 994) | fn mul_assign(&mut self, other: &'a Scalar) {
    method mul_assign (line 1002) | fn mul_assign(&mut self, other: Scalar) {
    method fmt (line 1024) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  method default (line 930) | fn default() -> Scalar {
  type Output (line 944) | type Output = Scalar;
  function add (line 945) | fn add(self, other: &'a Scalar) -> Scalar {
  type Output (line 985) | type Output = Scalar;
  function mul (line 986) | fn mul(self, other: &'a Scalar) -> Scalar {
  type Output (line 1008) | type Output = Scalar;
  method neg (line 1009) | fn neg(mut self) -> Scalar {
  type Output (line 1016) | type Output = Scalar;
  method neg (line 1017) | fn neg(self) -> Scalar {

FILE: gen/ecmult/src/lib.rs
  function generate_to (line 7) | pub fn generate_to(file: &mut File) -> Result<(), Error> {

FILE: gen/genmult/src/lib.rs
  function generate_to (line 9) | pub fn generate_to(file: &mut File) -> Result<(), Error> {

FILE: src/lib.rs
  type PublicKey (line 64) | pub struct PublicKey(Affine);
    method from_secret_key_with_context (line 107) | pub fn from_secret_key_with_context(
    method from_secret_key (line 119) | pub fn from_secret_key(seckey: &SecretKey) -> PublicKey {
    method parse_slice (line 123) | pub fn parse_slice(p: &[u8], format: Option<PublicKeyFormat>) -> Resul...
    method parse (line 158) | pub fn parse(p: &[u8; util::FULL_PUBLIC_KEY_SIZE]) -> Result<PublicKey...
    method parse_compressed (line 192) | pub fn parse_compressed(
    method serialize (line 216) | pub fn serialize(&self) -> [u8; util::FULL_PUBLIC_KEY_SIZE] {
    method serialize_compressed (line 233) | pub fn serialize_compressed(&self) -> [u8; util::COMPRESSED_PUBLIC_KEY...
    method tweak_add_assign_with_context (line 253) | pub fn tweak_add_assign_with_context(
    method tweak_add_assign (line 272) | pub fn tweak_add_assign(&mut self, tweak: &SecretKey) -> Result<(), Er...
    method tweak_mul_assign_with_context (line 276) | pub fn tweak_mul_assign_with_context(
    method tweak_mul_assign (line 295) | pub fn tweak_mul_assign(&mut self, tweak: &SecretKey) -> Result<(), Er...
    method combine (line 299) | pub fn combine(keys: &[PublicKey]) -> Result<Self, Error> {
    method into (line 317) | fn into(self) -> Affine {
    type Error (line 323) | type Error = Error;
    method try_from (line 325) | fn try_from(value: Affine) -> Result<Self, Self::Error> {
    method deserialize (line 399) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type SecretKey (line 68) | pub struct SecretKey(Scalar);
    method parse (line 412) | pub fn parse(p: &[u8; util::SECRET_KEY_SIZE]) -> Result<SecretKey, Err...
    method parse_slice (line 421) | pub fn parse_slice(p: &[u8]) -> Result<SecretKey, Error> {
    method random (line 431) | pub fn random<R: Rng>(rng: &mut R) -> SecretKey {
    method serialize (line 442) | pub fn serialize(&self) -> [u8; util::SECRET_KEY_SIZE] {
    method tweak_add_assign (line 446) | pub fn tweak_add_assign(&mut self, tweak: &SecretKey) -> Result<(), Er...
    method tweak_mul_assign (line 455) | pub fn tweak_mul_assign(&mut self, tweak: &SecretKey) -> Result<(), Er...
    method inv (line 464) | pub fn inv(&self) -> Self {
    method clear (line 468) | pub fn clear(&mut self) {
    method is_zero (line 472) | pub fn is_zero(&self) -> bool {
    method into (line 492) | fn into(self) -> Scalar {
    type Error (line 498) | type Error = Error;
    method try_from (line 500) | fn try_from(scalar: Scalar) -> Result<Self, Error> {
    method fmt (line 510) | fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
  type Signature (line 72) | pub struct Signature {
    method parse_overflowing (line 528) | pub fn parse_overflowing(p: &[u8; util::SIGNATURE_SIZE]) -> Signature {
    method parse_standard (line 541) | pub fn parse_standard(p: &[u8; util::SIGNATURE_SIZE]) -> Result<Signat...
    method parse_overflowing_slice (line 561) | pub fn parse_overflowing_slice(p: &[u8]) -> Result<Signature, Error> {
    method parse_standard_slice (line 572) | pub fn parse_standard_slice(p: &[u8]) -> Result<Signature, Error> {
    method parse_der (line 583) | pub fn parse_der(p: &[u8]) -> Result<Signature, Error> {
    method parse_der_lax (line 607) | pub fn parse_der_lax(p: &[u8]) -> Result<Signature, Error> {
    method normalize_s (line 636) | pub fn normalize_s(&mut self) {
    method serialize (line 644) | pub fn serialize(&self) -> [u8; util::SIGNATURE_SIZE] {
    method serialize_der (line 653) | pub fn serialize_der(&self) -> SignatureArray {
  type RecoveryId (line 79) | pub struct RecoveryId(u8);
    method parse (line 718) | pub fn parse(p: u8) -> Result<RecoveryId, Error> {
    method parse_rpc (line 727) | pub fn parse_rpc(p: u8) -> Result<RecoveryId, Error> {
    method serialize (line 735) | pub fn serialize(&self) -> u8 {
    method into (line 741) | fn into(self) -> u8 {
    method into (line 747) | fn into(self) -> i32 {
  type Message (line 83) | pub struct Message(pub Scalar);
    method parse (line 692) | pub fn parse(p: &[u8; util::MESSAGE_SIZE]) -> Message {
    method parse_slice (line 701) | pub fn parse_slice(p: &[u8]) -> Result<Message, Error> {
    method serialize (line 711) | pub fn serialize(&self) -> [u8; util::MESSAGE_SIZE] {
  type SharedSecret (line 87) | pub struct SharedSecret<D: Digest>(GenericArray<u8, D::OutputSize>);
  type PublicKeyFormat (line 97) | pub enum PublicKeyFormat {
  method serialize (line 336) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
  type PublicKeyStrVisitor (line 349) | struct PublicKeyStrVisitor;
    type Value (line 353) | type Value = PublicKey;
    method expecting (line 355) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_str (line 360) | fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
  type PublicKeyBytesVisitor (line 377) | struct PublicKeyBytesVisitor;
    type Value (line 381) | type Value = PublicKey;
    method expecting (line 383) | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
    method visit_bytes (line 389) | fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
  method default (line 478) | fn default() -> SecretKey {
  function new_with_context (line 753) | pub fn new_with_context(
  function new (line 767) | pub fn new(pubkey: &PublicKey, seckey: &SecretKey) -> Result<SharedSecre...
  function as_ref (line 773) | fn as_ref(&self) -> &[u8] {
  function verify_with_context (line 779) | pub fn verify_with_context(
  function verify (line 790) | pub fn verify(message: &Message, signature: &Signature, pubkey: &PublicK...
  function recover_with_context (line 795) | pub fn recover_with_context(
  function recover (line 808) | pub fn recover(
  function sign_with_context (line 818) | pub fn sign_with_context(
  function sign (line 857) | pub fn sign(message: &Message, seckey: &SecretKey) -> (Signature, Recove...
  function secret_key_inverse_is_sane (line 867) | fn secret_key_inverse_is_sane() {
  function secret_key_clear_is_correct (line 883) | fn secret_key_clear_is_correct() {

FILE: tests/serde.rs
  constant DEBUG_SECRET_KEY (line 5) | const DEBUG_SECRET_KEY: [u8; 32] = [1u8; 32];
  constant SERIALIZED_DEBUG_PUBLIC_KEY (line 7) | const SERIALIZED_DEBUG_PUBLIC_KEY: &str =
  function debug_public_key (line 10) | fn debug_public_key() -> PublicKey {
  function test_serialize_public_key (line 16) | fn test_serialize_public_key() {
  function test_deserialize_public_key (line 23) | fn test_deserialize_public_key() {
  function test_public_key_bincode_serde (line 29) | fn test_public_key_bincode_serde() {

FILE: tests/verify.rs
  function genkey (line 21) | fn genkey(
  function test_signature_der (line 38) | fn test_signature_der() {
  function test_sign_verify (line 59) | fn test_sign_verify() {
  function test_failing_sign_verify (line 110) | fn test_failing_sign_verify() {
  function test_shared_secret (line 133) | fn test_shared_secret() {
  function test_verify (line 158) | fn test_verify() {
  function secret_clear_on_drop (line 199) | fn secret_clear_on_drop() {
  function test_recover (line 208) | fn test_recover() {
  function from_hex (line 238) | fn from_hex(hex: &str, target: &mut [u8]) -> Result<usize, ()> {
  function test_signature_der_lax (line 271) | fn test_signature_der_lax() {
  function test_low_s (line 289) | fn test_low_s() {
  function test_convert_key1 (line 324) | fn test_convert_key1() {
  function test_convert_key2 (line 345) | fn test_convert_key2() {
  function test_convert_anykey (line 366) | fn test_convert_anykey() {
  function test_pubkey_combine (line 394) | fn test_pubkey_combine() {
  function test_pubkey_equality (line 421) | fn test_pubkey_equality() {

FILE: tests/wycheproof.rs
  type TestCollection (line 8) | struct TestCollection {
  type TestGroup (line 21) | struct TestGroup {
  type TestKey (line 34) | struct TestKey {
  type TestUnit (line 47) | struct TestUnit {
  type TestResult (line 58) | enum TestResult {
  type TestError (line 64) | enum TestError {
  function test_unit (line 70) | fn test_unit(test: &TestUnit, key: &libsecp256k1::PublicKey) -> Result<(...
  function test_wycheproof (line 90) | fn test_wycheproof() {