mirror of
https://github.com/dashpay/dash.git
synced 2024-12-25 12:02:48 +01:00
110 lines
3.4 KiB
C++
110 lines
3.4 KiB
C++
// Copyright 2018 Chia Network Inc
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#ifndef SRC_EXTENDEDPUBLICKEY_HPP_
|
|
#define SRC_EXTENDEDPUBLICKEY_HPP_
|
|
|
|
#include "relic_conf.h"
|
|
|
|
#include <vector>
|
|
|
|
#if defined GMP && ARITH == GMP
|
|
#include <gmp.h>
|
|
#endif
|
|
|
|
#include "chaincode.hpp"
|
|
#include "elements.hpp"
|
|
|
|
|
|
#include "relic.h"
|
|
#include "relic_test.h"
|
|
|
|
namespace bls {
|
|
|
|
/*
|
|
Defines a BIP-32 style node, which is composed of a private key and a
|
|
chain code. This follows the spec from BIP-0032, with a few changes:
|
|
* The master secret key is generated mod n from the master seed,
|
|
since not all 32 byte sequences are valid BLS private keys
|
|
* Instead of SHA512(input), do SHA256(input || 00000000) ||
|
|
SHA256(input || 00000001)
|
|
* Mod n for the output of key derivation.
|
|
* ID of a key is SHA256(pk) instead of HASH160(pk)
|
|
* Serialization of extended public key is 93 bytes
|
|
*/
|
|
class ExtendedPublicKey {
|
|
public:
|
|
static const uint32_t REVISION = 1;
|
|
|
|
// version(4) depth(1) parent fingerprint(4) child#(4) cc(32) pk(48)
|
|
static const uint32_t SIZE = 93;
|
|
|
|
// Parse public key and chain code from bytes
|
|
static ExtendedPublicKey FromBytes(const Bytes& bytes, bool fLegacy = true);
|
|
|
|
// Derive a child extended public key, cannot be hardened
|
|
ExtendedPublicKey PublicChild(uint32_t i, bool fLegacy = true) const;
|
|
|
|
uint32_t GetVersion() const;
|
|
uint8_t GetDepth() const;
|
|
uint32_t GetParentFingerprint() const;
|
|
uint32_t GetChildNumber() const;
|
|
|
|
ChainCode GetChainCode() const;
|
|
G1Element GetPublicKey() const;
|
|
|
|
// Comparator implementation.
|
|
friend bool operator==(ExtendedPublicKey const &a,
|
|
ExtendedPublicKey const &b);
|
|
friend bool operator!=(ExtendedPublicKey const &a,
|
|
ExtendedPublicKey const &b);
|
|
friend std::ostream &operator<<(std::ostream &os,
|
|
ExtendedPublicKey const &s);
|
|
|
|
void Serialize(uint8_t *buffer, bool fLegacy = true) const;
|
|
std::vector<uint8_t> Serialize(bool fLegacy = true) const;
|
|
|
|
// Blank public constructor
|
|
ExtendedPublicKey()
|
|
: version(0),
|
|
depth(0),
|
|
parentFingerprint(0),
|
|
childNumber(0),
|
|
chainCode(ChainCode()),
|
|
pk(G1Element()) {}
|
|
|
|
private:
|
|
// private constructor, force use of static methods
|
|
explicit ExtendedPublicKey(const uint32_t v, const uint8_t d,
|
|
const uint32_t pfp, const uint32_t cn,
|
|
const ChainCode code, const G1Element key)
|
|
: version(v),
|
|
depth(d),
|
|
parentFingerprint(pfp),
|
|
childNumber(cn),
|
|
chainCode(code),
|
|
pk(key) {}
|
|
|
|
uint32_t version;
|
|
uint8_t depth;
|
|
uint32_t parentFingerprint;
|
|
uint32_t childNumber;
|
|
|
|
ChainCode chainCode;
|
|
G1Element pk;
|
|
};
|
|
} // end namespace bls
|
|
|
|
#endif // SRC_EXTENDEDPUBLICKEY_HPP_
|