Class: Secp256k1::RecoverableSignature

Inherits:

Object

• Object
• Secp256k1::RecoverableSignature

Defined in:

ext/rbsecp256k1/rbsecp256k1.c

Instance Method Summary

• #==(other) ⇒ Boolean

  Compares two recoverable signatures.

• #compact ⇒ Array

  Returns the compact encoding of recoverable signature.

• #recover_public_key(in_hash32) ⇒ Secp256k1::PublicKey

  Attempts to recover the public key associated with this signature.

• #to_signature ⇒ Secp256k1::Signature

  Convert a recoverable signature to a non-recoverable signature.

Instance Method Details

#==(other) ⇒ Boolean

Compares two recoverable signatures.

Two recoverable signatures their secp256k1_ecdsa_recoverable_signature data is identical.

Parameters:

• other (Secp256k1::RecoverableSignature) —

  recoverable signature to compare.

Returns:

• (Boolean) —

  true if the recoverable signatures are identical, false otherwise.

# File 'ext/rbsecp256k1/rbsecp256k1.c', line 1307

static VALUE
RecoverableSignature_equals(VALUE self, VALUE other)
{
  RecoverableSignature *lhs;
  RecoverableSignature *rhs;

  TypedData_Get_Struct(
    self, RecoverableSignature, &RecoverableSignature_DataType, lhs
  );
  TypedData_Get_Struct(
    other, RecoverableSignature, &RecoverableSignature_DataType, rhs
  );

  // NOTE: It is safe to directly compare these data structures rather than
  // first serializing and then comparing.
  if (memcmp(&(lhs->sig),
             &(rhs->sig),
             sizeof(secp256k1_ecdsa_recoverable_signature)) == 0)
  {
    return Qtrue;
  }

  return Qfalse;
}

#compact ⇒ Array

Returns the compact encoding of recoverable signature.

Returns:

• (Array) —

  first element is the 64 byte compact encoding of signature, the second element is the integer recovery ID.

Raises:

• (Secp256k1::SerializationError) —

  if signature serialization fails.

# File 'ext/rbsecp256k1/rbsecp256k1.c', line 1177

static VALUE
RecoverableSignature_compact(VALUE self)
{
  RecoverableSignature *recoverable_signature;
  unsigned char compact_sig[64];
  int recovery_id;
  VALUE result;

  TypedData_Get_Struct(
    self,
    RecoverableSignature,
    &RecoverableSignature_DataType,
    recoverable_signature
  );

  if (secp256k1_ecdsa_recoverable_signature_serialize_compact(
        recoverable_signature->ctx,
        compact_sig,
        &recovery_id,
        &(recoverable_signature->sig)) != 1)
  {
    rb_raise(
      Secp256k1_SerializationError_class,
      "unable to serialize recoverable signature"
    );
    return Qnil;
  }

  // Create a new array with room for 2 elements and push data onto it
  result = rb_ary_new2(2);
  rb_ary_push(result, rb_str_new((char*)compact_sig, 64));
  rb_ary_push(result, rb_int_new(recovery_id));

  return result;
}

#recover_public_key(in_hash32) ⇒ Secp256k1::PublicKey

Attempts to recover the public key associated with this signature.

Parameters:

• in_hash32 (String) —

  32-byte SHA-256 hash of data.

Returns:

• (Secp256k1::PublicKey) —

  recovered public key.

Raises:

• (Secp256k1::Error) —

  if hash given is not 32 bytes.

• (Secp256k1::DeserializationError) —

  if public key could not be recovered.

# File 'ext/rbsecp256k1/rbsecp256k1.c', line 1259

static VALUE
RecoverableSignature_recover_public_key(VALUE self, VALUE in_hash32)
{
  RecoverableSignature *recoverable_signature;
  PublicKey *public_key;
  VALUE result;
  unsigned char *hash32;

  Check_Type(in_hash32, T_STRING);
  if (RSTRING_LEN(in_hash32) != 32)
  {
    rb_raise(Secp256k1_Error_class, "in_hash32 is not 32 bytes in length");
    return Qnil;
  }

  TypedData_Get_Struct(
    self,
    RecoverableSignature,
    &RecoverableSignature_DataType,
    recoverable_signature
  );
  hash32 = (unsigned char*)StringValuePtr(in_hash32);

  result = PublicKey_alloc(Secp256k1_PublicKey_class);
  TypedData_Get_Struct(result, PublicKey, &PublicKey_DataType, public_key);

  if (secp256k1_ecdsa_recover(recoverable_signature->ctx,
                              &(public_key->pubkey),
                              &(recoverable_signature->sig),
                              hash32) == 1)
  {
    return result;
  }

  rb_raise(Secp256k1_DeserializationError_class, "unable to recover public key");
}

#to_signature ⇒ Secp256k1::Signature

Convert a recoverable signature to a non-recoverable signature.

Returns:

• (Secp256k1::Signature) —

  non-recoverable signature derived from this recoverable signature.

# File 'ext/rbsecp256k1/rbsecp256k1.c', line 1219

static VALUE
RecoverableSignature_to_signature(VALUE self)
{
  RecoverableSignature *recoverable_signature;
  Signature *signature;
  VALUE result;

  TypedData_Get_Struct(
    self,
    RecoverableSignature,
    &RecoverableSignature_DataType,
    recoverable_signature
  );

  result = Signature_alloc(Secp256k1_Signature_class);
  TypedData_Get_Struct(
    result,
    Signature,
    &Signature_DataType,
    signature
  );

  // NOTE: This method cannot fail
  secp256k1_ecdsa_recoverable_signature_convert(
    recoverable_signature->ctx,
    &(signature->sig),
    &(recoverable_signature->sig));

  return result;
}