Struct bitcoin::PublicKey

pub struct PublicKey(pub [u8; 33]);

Compressed ECDSA (secp256k1 curve) Public Key

Tuple Fields

0: [u8; 33]

Implementations

impl PublicKey

To avoid the use of OP_RETURN during the issue process, we use an On-chain Key Derivation scheme (OKD) for Bitcoin’s ECDSA (secp256k1 curve). The vault-registry maintains a “master” public key for each registered Vault which can then be used to derive additional deposit addresses on-demand. Each new issue request triggers the computation of a deposit address. The scheme works as follows:

Preliminaries

A Vault has a private/public keypair (v, V), where V = v·G and G is the base point of the secp256k1 curve. Upon registration, the Vault submits public key V to the BTC-Parachain storage.

OKD scheme

1. Computes c = H(V || id), where id is the unique issue identifier, generated on-chain by the BTC-Parachain using the user’s AccountId and an internal auto-incrementing nonce as input.
2. Generates a new public key (“deposit public key”) D = V·c and then the corresponding BTC RIPEMD-160 hash-based address addr(D) (‘deposit’ address) using D as input.
3. Stores D and addr(D) alongside the id of the issue request.
4. The vault knows that the private key of D is c·v, where c = H(V || id) is publicly known (so it can be computed by the vault off-chain, or stored on-chain for convenience). The vault can now import the private key

pub fn new_deposit_public_key( &self, secure_id: H256 ) -> Result<Self, Secp256k1Error>

Generates an ephemeral “deposit” public key which can be used in Issue requests to ensure that payments are unique.

Arguments

• secure_id - random nonce (as provided by the security module)

pub fn to_hash(&self) -> H160

Calculates the RIPEMD-160 hash of the compressed public key, which can be used to formulate an Address.

pub fn as_bytes(&self) -> &[u8]

pub fn to_p2pkh_script_sig(&self, sig: Vec<u8>) -> Script

Construct the p2pkh scriptSig for this compressed pubKey given the signature. Note: we do not check signatures on verification, but this should be non-empty.

pub fn to_p2sh_script_sig(&self, sig: Vec<u8>) -> Script

Construct the scriptSig for a one-signature-required p2sh transaction, given the key’s signature. Note: we do not verify that the signature is valid but this field must be non-empty for parsing to succeed.

pub const fn dummy() -> Self

Trait Implementations

impl Clone for PublicKey

fn clone(&self) -> PublicKey

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PublicKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for PublicKey

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl Default for PublicKey

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PublicKey

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for PublicKey

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )

Convert self to a slice and append it to the destination.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl From<[u8; 33]> for PublicKey

fn from(bytes: [u8; 33]) -> Self

Converts to this type from the input type.

impl MaxEncodedLen for PublicKey

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.

impl PartialEq<PublicKey> for PublicKey

fn eq(&self, other: &PublicKey) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for PublicKey

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where S: Serializer,

Serialize this value into the given Serde serializer.

impl TypeInfo for PublicKey

type Identity = PublicKey

The type identifying for which type info is provided.

fn type_info() -> Type

Returns the static type identifier for Self.

impl EncodeLike<PublicKey> for PublicKey

impl Eq for PublicKey

impl StructuralEq for PublicKey

impl StructuralPartialEq for PublicKey