mirror of
https://github.com/kaspanet/kaspad.git
synced 2025-03-30 15:08:33 +00:00
43b9523919
* Adding support for mass. * update grpc v1.69.2 * Upgrade protos using latest protoc * Use MassCommitment instead of Mass * Fix DomainTransaction clone, equal and tests --------- Co-authored-by: veronica <jimjouny@gmail.com> Co-authored-by: Ori Newman <orinewman1@gmail.com>
605 lines
22 KiB
Go
605 lines
22 KiB
Go
package appmessage
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"math/big"
|
|
|
|
"github.com/pkg/errors"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/blockheader"
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/hashes"
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/utxo"
|
|
|
|
"github.com/kaspanet/kaspad/domain/consensus/model/externalapi"
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/subnetworks"
|
|
"github.com/kaspanet/kaspad/domain/consensus/utils/transactionid"
|
|
"github.com/kaspanet/kaspad/util/mstime"
|
|
)
|
|
|
|
// DomainBlockToMsgBlock converts an externalapi.DomainBlock to MsgBlock
|
|
func DomainBlockToMsgBlock(domainBlock *externalapi.DomainBlock) *MsgBlock {
|
|
msgTxs := make([]*MsgTx, 0, len(domainBlock.Transactions))
|
|
for _, domainTransaction := range domainBlock.Transactions {
|
|
msgTxs = append(msgTxs, DomainTransactionToMsgTx(domainTransaction))
|
|
}
|
|
return &MsgBlock{
|
|
Header: *DomainBlockHeaderToBlockHeader(domainBlock.Header),
|
|
Transactions: msgTxs,
|
|
}
|
|
}
|
|
|
|
// DomainBlockHeaderToBlockHeader converts an externalapi.BlockHeader to MsgBlockHeader
|
|
func DomainBlockHeaderToBlockHeader(domainBlockHeader externalapi.BlockHeader) *MsgBlockHeader {
|
|
return &MsgBlockHeader{
|
|
Version: domainBlockHeader.Version(),
|
|
Parents: domainBlockHeader.Parents(),
|
|
HashMerkleRoot: domainBlockHeader.HashMerkleRoot(),
|
|
AcceptedIDMerkleRoot: domainBlockHeader.AcceptedIDMerkleRoot(),
|
|
UTXOCommitment: domainBlockHeader.UTXOCommitment(),
|
|
Timestamp: mstime.UnixMilliseconds(domainBlockHeader.TimeInMilliseconds()),
|
|
Bits: domainBlockHeader.Bits(),
|
|
Nonce: domainBlockHeader.Nonce(),
|
|
BlueScore: domainBlockHeader.BlueScore(),
|
|
DAAScore: domainBlockHeader.DAAScore(),
|
|
BlueWork: domainBlockHeader.BlueWork(),
|
|
PruningPoint: domainBlockHeader.PruningPoint(),
|
|
}
|
|
}
|
|
|
|
// MsgBlockToDomainBlock converts a MsgBlock to externalapi.DomainBlock
|
|
func MsgBlockToDomainBlock(msgBlock *MsgBlock) *externalapi.DomainBlock {
|
|
transactions := make([]*externalapi.DomainTransaction, 0, len(msgBlock.Transactions))
|
|
for _, msgTx := range msgBlock.Transactions {
|
|
transactions = append(transactions, MsgTxToDomainTransaction(msgTx))
|
|
}
|
|
|
|
return &externalapi.DomainBlock{
|
|
Header: BlockHeaderToDomainBlockHeader(&msgBlock.Header),
|
|
Transactions: transactions,
|
|
}
|
|
}
|
|
|
|
// BlockHeaderToDomainBlockHeader converts a MsgBlockHeader to externalapi.BlockHeader
|
|
func BlockHeaderToDomainBlockHeader(blockHeader *MsgBlockHeader) externalapi.BlockHeader {
|
|
return blockheader.NewImmutableBlockHeader(
|
|
blockHeader.Version,
|
|
blockHeader.Parents,
|
|
blockHeader.HashMerkleRoot,
|
|
blockHeader.AcceptedIDMerkleRoot,
|
|
blockHeader.UTXOCommitment,
|
|
blockHeader.Timestamp.UnixMilliseconds(),
|
|
blockHeader.Bits,
|
|
blockHeader.Nonce,
|
|
blockHeader.DAAScore,
|
|
blockHeader.BlueScore,
|
|
blockHeader.BlueWork,
|
|
blockHeader.PruningPoint,
|
|
)
|
|
}
|
|
|
|
// DomainTransactionToMsgTx converts an externalapi.DomainTransaction into an MsgTx
|
|
func DomainTransactionToMsgTx(domainTransaction *externalapi.DomainTransaction) *MsgTx {
|
|
txIns := make([]*TxIn, 0, len(domainTransaction.Inputs))
|
|
for _, input := range domainTransaction.Inputs {
|
|
txIns = append(txIns, domainTransactionInputToTxIn(input))
|
|
}
|
|
|
|
txOuts := make([]*TxOut, 0, len(domainTransaction.Outputs))
|
|
for _, output := range domainTransaction.Outputs {
|
|
txOuts = append(txOuts, domainTransactionOutputToTxOut(output))
|
|
}
|
|
|
|
return &MsgTx{
|
|
Version: domainTransaction.Version,
|
|
TxIn: txIns,
|
|
TxOut: txOuts,
|
|
LockTime: domainTransaction.LockTime,
|
|
SubnetworkID: domainTransaction.SubnetworkID,
|
|
Gas: domainTransaction.Gas,
|
|
Payload: domainTransaction.Payload,
|
|
}
|
|
}
|
|
|
|
func domainTransactionOutputToTxOut(domainTransactionOutput *externalapi.DomainTransactionOutput) *TxOut {
|
|
return &TxOut{
|
|
Value: domainTransactionOutput.Value,
|
|
ScriptPubKey: domainTransactionOutput.ScriptPublicKey,
|
|
}
|
|
}
|
|
|
|
func domainTransactionInputToTxIn(domainTransactionInput *externalapi.DomainTransactionInput) *TxIn {
|
|
return &TxIn{
|
|
PreviousOutpoint: *domainOutpointToOutpoint(domainTransactionInput.PreviousOutpoint),
|
|
SignatureScript: domainTransactionInput.SignatureScript,
|
|
Sequence: domainTransactionInput.Sequence,
|
|
SigOpCount: domainTransactionInput.SigOpCount,
|
|
}
|
|
}
|
|
|
|
func domainOutpointToOutpoint(domainOutpoint externalapi.DomainOutpoint) *Outpoint {
|
|
return NewOutpoint(
|
|
&domainOutpoint.TransactionID,
|
|
domainOutpoint.Index)
|
|
}
|
|
|
|
// MsgTxToDomainTransaction converts an MsgTx into externalapi.DomainTransaction
|
|
func MsgTxToDomainTransaction(msgTx *MsgTx) *externalapi.DomainTransaction {
|
|
transactionInputs := make([]*externalapi.DomainTransactionInput, 0, len(msgTx.TxIn))
|
|
for _, txIn := range msgTx.TxIn {
|
|
transactionInputs = append(transactionInputs, txInToDomainTransactionInput(txIn))
|
|
}
|
|
|
|
transactionOutputs := make([]*externalapi.DomainTransactionOutput, 0, len(msgTx.TxOut))
|
|
for _, txOut := range msgTx.TxOut {
|
|
transactionOutputs = append(transactionOutputs, txOutToDomainTransactionOutput(txOut))
|
|
}
|
|
|
|
payload := make([]byte, 0)
|
|
if msgTx.Payload != nil {
|
|
payload = msgTx.Payload
|
|
}
|
|
|
|
return &externalapi.DomainTransaction{
|
|
Version: msgTx.Version,
|
|
Inputs: transactionInputs,
|
|
Outputs: transactionOutputs,
|
|
LockTime: msgTx.LockTime,
|
|
SubnetworkID: msgTx.SubnetworkID,
|
|
Gas: msgTx.Gas,
|
|
Payload: payload,
|
|
}
|
|
}
|
|
|
|
func txOutToDomainTransactionOutput(txOut *TxOut) *externalapi.DomainTransactionOutput {
|
|
return &externalapi.DomainTransactionOutput{
|
|
Value: txOut.Value,
|
|
ScriptPublicKey: txOut.ScriptPubKey,
|
|
}
|
|
}
|
|
|
|
func txInToDomainTransactionInput(txIn *TxIn) *externalapi.DomainTransactionInput {
|
|
return &externalapi.DomainTransactionInput{
|
|
PreviousOutpoint: *outpointToDomainOutpoint(&txIn.PreviousOutpoint), //TODO
|
|
SignatureScript: txIn.SignatureScript,
|
|
SigOpCount: txIn.SigOpCount,
|
|
Sequence: txIn.Sequence,
|
|
}
|
|
}
|
|
|
|
func outpointToDomainOutpoint(outpoint *Outpoint) *externalapi.DomainOutpoint {
|
|
return &externalapi.DomainOutpoint{
|
|
TransactionID: outpoint.TxID,
|
|
Index: outpoint.Index,
|
|
}
|
|
}
|
|
|
|
// RPCTransactionToDomainTransaction converts RPCTransactions to DomainTransactions
|
|
func RPCTransactionToDomainTransaction(rpcTransaction *RPCTransaction) (*externalapi.DomainTransaction, error) {
|
|
inputs := make([]*externalapi.DomainTransactionInput, len(rpcTransaction.Inputs))
|
|
for i, input := range rpcTransaction.Inputs {
|
|
previousOutpoint, err := RPCOutpointToDomainOutpoint(input.PreviousOutpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
signatureScript, err := hex.DecodeString(input.SignatureScript)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
inputs[i] = &externalapi.DomainTransactionInput{
|
|
PreviousOutpoint: *previousOutpoint,
|
|
SignatureScript: signatureScript,
|
|
Sequence: input.Sequence,
|
|
SigOpCount: input.SigOpCount,
|
|
}
|
|
}
|
|
outputs := make([]*externalapi.DomainTransactionOutput, len(rpcTransaction.Outputs))
|
|
for i, output := range rpcTransaction.Outputs {
|
|
scriptPublicKey, err := hex.DecodeString(output.ScriptPublicKey.Script)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
outputs[i] = &externalapi.DomainTransactionOutput{
|
|
Value: output.Amount,
|
|
ScriptPublicKey: &externalapi.ScriptPublicKey{Script: scriptPublicKey, Version: output.ScriptPublicKey.Version},
|
|
}
|
|
}
|
|
|
|
subnetworkID, err := subnetworks.FromString(rpcTransaction.SubnetworkID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
payload, err := hex.DecodeString(rpcTransaction.Payload)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &externalapi.DomainTransaction{
|
|
Version: rpcTransaction.Version,
|
|
Inputs: inputs,
|
|
Outputs: outputs,
|
|
LockTime: rpcTransaction.LockTime,
|
|
SubnetworkID: *subnetworkID,
|
|
Gas: rpcTransaction.Gas,
|
|
MassCommitment: rpcTransaction.Mass,
|
|
Payload: payload,
|
|
}, nil
|
|
}
|
|
|
|
// RPCOutpointToDomainOutpoint converts RPCOutpoint to DomainOutpoint
|
|
func RPCOutpointToDomainOutpoint(outpoint *RPCOutpoint) (*externalapi.DomainOutpoint, error) {
|
|
transactionID, err := transactionid.FromString(outpoint.TransactionID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &externalapi.DomainOutpoint{
|
|
TransactionID: *transactionID,
|
|
Index: outpoint.Index,
|
|
}, nil
|
|
}
|
|
|
|
// RPCUTXOEntryToUTXOEntry converts RPCUTXOEntry to UTXOEntry
|
|
func RPCUTXOEntryToUTXOEntry(entry *RPCUTXOEntry) (externalapi.UTXOEntry, error) {
|
|
script, err := hex.DecodeString(entry.ScriptPublicKey.Script)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return utxo.NewUTXOEntry(
|
|
entry.Amount,
|
|
&externalapi.ScriptPublicKey{
|
|
Script: script,
|
|
Version: entry.ScriptPublicKey.Version,
|
|
},
|
|
entry.IsCoinbase,
|
|
entry.BlockDAAScore,
|
|
), nil
|
|
}
|
|
|
|
// DomainTransactionToRPCTransaction converts DomainTransactions to RPCTransactions
|
|
func DomainTransactionToRPCTransaction(transaction *externalapi.DomainTransaction) *RPCTransaction {
|
|
inputs := make([]*RPCTransactionInput, len(transaction.Inputs))
|
|
for i, input := range transaction.Inputs {
|
|
transactionID := input.PreviousOutpoint.TransactionID.String()
|
|
previousOutpoint := &RPCOutpoint{
|
|
TransactionID: transactionID,
|
|
Index: input.PreviousOutpoint.Index,
|
|
}
|
|
signatureScript := hex.EncodeToString(input.SignatureScript)
|
|
inputs[i] = &RPCTransactionInput{
|
|
PreviousOutpoint: previousOutpoint,
|
|
SignatureScript: signatureScript,
|
|
Sequence: input.Sequence,
|
|
SigOpCount: input.SigOpCount,
|
|
}
|
|
}
|
|
outputs := make([]*RPCTransactionOutput, len(transaction.Outputs))
|
|
for i, output := range transaction.Outputs {
|
|
scriptPublicKey := hex.EncodeToString(output.ScriptPublicKey.Script)
|
|
outputs[i] = &RPCTransactionOutput{
|
|
Amount: output.Value,
|
|
ScriptPublicKey: &RPCScriptPublicKey{Script: scriptPublicKey, Version: output.ScriptPublicKey.Version},
|
|
}
|
|
}
|
|
subnetworkID := transaction.SubnetworkID.String()
|
|
payload := hex.EncodeToString(transaction.Payload)
|
|
return &RPCTransaction{
|
|
Version: transaction.Version,
|
|
Inputs: inputs,
|
|
Outputs: outputs,
|
|
LockTime: transaction.LockTime,
|
|
SubnetworkID: subnetworkID,
|
|
Gas: transaction.Gas,
|
|
Mass: transaction.MassCommitment,
|
|
Payload: payload,
|
|
}
|
|
}
|
|
|
|
// OutpointAndUTXOEntryPairsToDomainOutpointAndUTXOEntryPairs converts
|
|
// OutpointAndUTXOEntryPairs to domain OutpointAndUTXOEntryPairs
|
|
func OutpointAndUTXOEntryPairsToDomainOutpointAndUTXOEntryPairs(
|
|
outpointAndUTXOEntryPairs []*OutpointAndUTXOEntryPair) []*externalapi.OutpointAndUTXOEntryPair {
|
|
|
|
domainOutpointAndUTXOEntryPairs := make([]*externalapi.OutpointAndUTXOEntryPair, len(outpointAndUTXOEntryPairs))
|
|
for i, outpointAndUTXOEntryPair := range outpointAndUTXOEntryPairs {
|
|
domainOutpointAndUTXOEntryPairs[i] = outpointAndUTXOEntryPairToDomainOutpointAndUTXOEntryPair(outpointAndUTXOEntryPair)
|
|
}
|
|
return domainOutpointAndUTXOEntryPairs
|
|
}
|
|
|
|
func outpointAndUTXOEntryPairToDomainOutpointAndUTXOEntryPair(
|
|
outpointAndUTXOEntryPair *OutpointAndUTXOEntryPair) *externalapi.OutpointAndUTXOEntryPair {
|
|
return &externalapi.OutpointAndUTXOEntryPair{
|
|
Outpoint: &externalapi.DomainOutpoint{
|
|
TransactionID: outpointAndUTXOEntryPair.Outpoint.TxID,
|
|
Index: outpointAndUTXOEntryPair.Outpoint.Index,
|
|
},
|
|
UTXOEntry: utxo.NewUTXOEntry(
|
|
outpointAndUTXOEntryPair.UTXOEntry.Amount,
|
|
outpointAndUTXOEntryPair.UTXOEntry.ScriptPublicKey,
|
|
outpointAndUTXOEntryPair.UTXOEntry.IsCoinbase,
|
|
outpointAndUTXOEntryPair.UTXOEntry.BlockDAAScore,
|
|
),
|
|
}
|
|
}
|
|
|
|
// DomainOutpointAndUTXOEntryPairsToOutpointAndUTXOEntryPairs converts
|
|
// domain OutpointAndUTXOEntryPairs to OutpointAndUTXOEntryPairs
|
|
func DomainOutpointAndUTXOEntryPairsToOutpointAndUTXOEntryPairs(
|
|
outpointAndUTXOEntryPairs []*externalapi.OutpointAndUTXOEntryPair) []*OutpointAndUTXOEntryPair {
|
|
|
|
domainOutpointAndUTXOEntryPairs := make([]*OutpointAndUTXOEntryPair, len(outpointAndUTXOEntryPairs))
|
|
for i, outpointAndUTXOEntryPair := range outpointAndUTXOEntryPairs {
|
|
domainOutpointAndUTXOEntryPairs[i] = &OutpointAndUTXOEntryPair{
|
|
Outpoint: &Outpoint{
|
|
TxID: outpointAndUTXOEntryPair.Outpoint.TransactionID,
|
|
Index: outpointAndUTXOEntryPair.Outpoint.Index,
|
|
},
|
|
UTXOEntry: &UTXOEntry{
|
|
Amount: outpointAndUTXOEntryPair.UTXOEntry.Amount(),
|
|
ScriptPublicKey: outpointAndUTXOEntryPair.UTXOEntry.ScriptPublicKey(),
|
|
IsCoinbase: outpointAndUTXOEntryPair.UTXOEntry.IsCoinbase(),
|
|
BlockDAAScore: outpointAndUTXOEntryPair.UTXOEntry.BlockDAAScore(),
|
|
},
|
|
}
|
|
}
|
|
return domainOutpointAndUTXOEntryPairs
|
|
}
|
|
|
|
// DomainBlockToRPCBlock converts DomainBlocks to RPCBlocks
|
|
func DomainBlockToRPCBlock(block *externalapi.DomainBlock) *RPCBlock {
|
|
parents := make([]*RPCBlockLevelParents, len(block.Header.Parents()))
|
|
for i, blockLevelParents := range block.Header.Parents() {
|
|
parents[i] = &RPCBlockLevelParents{
|
|
ParentHashes: hashes.ToStrings(blockLevelParents),
|
|
}
|
|
}
|
|
header := &RPCBlockHeader{
|
|
Version: uint32(block.Header.Version()),
|
|
Parents: parents,
|
|
HashMerkleRoot: block.Header.HashMerkleRoot().String(),
|
|
AcceptedIDMerkleRoot: block.Header.AcceptedIDMerkleRoot().String(),
|
|
UTXOCommitment: block.Header.UTXOCommitment().String(),
|
|
Timestamp: block.Header.TimeInMilliseconds(),
|
|
Bits: block.Header.Bits(),
|
|
Nonce: block.Header.Nonce(),
|
|
DAAScore: block.Header.DAAScore(),
|
|
BlueScore: block.Header.BlueScore(),
|
|
BlueWork: block.Header.BlueWork().Text(16),
|
|
PruningPoint: block.Header.PruningPoint().String(),
|
|
}
|
|
transactions := make([]*RPCTransaction, len(block.Transactions))
|
|
for i, transaction := range block.Transactions {
|
|
transactions[i] = DomainTransactionToRPCTransaction(transaction)
|
|
}
|
|
return &RPCBlock{
|
|
Header: header,
|
|
Transactions: transactions,
|
|
}
|
|
}
|
|
|
|
// RPCBlockToDomainBlock converts `block` into a DomainBlock
|
|
func RPCBlockToDomainBlock(block *RPCBlock) (*externalapi.DomainBlock, error) {
|
|
parents := make([]externalapi.BlockLevelParents, len(block.Header.Parents))
|
|
for i, blockLevelParents := range block.Header.Parents {
|
|
parents[i] = make(externalapi.BlockLevelParents, len(blockLevelParents.ParentHashes))
|
|
for j, parentHash := range blockLevelParents.ParentHashes {
|
|
var err error
|
|
parents[i][j], err = externalapi.NewDomainHashFromString(parentHash)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
hashMerkleRoot, err := externalapi.NewDomainHashFromString(block.Header.HashMerkleRoot)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
acceptedIDMerkleRoot, err := externalapi.NewDomainHashFromString(block.Header.AcceptedIDMerkleRoot)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
utxoCommitment, err := externalapi.NewDomainHashFromString(block.Header.UTXOCommitment)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
blueWork, success := new(big.Int).SetString(block.Header.BlueWork, 16)
|
|
if !success {
|
|
return nil, errors.Errorf("failed to parse blue work: %s", block.Header.BlueWork)
|
|
}
|
|
pruningPoint, err := externalapi.NewDomainHashFromString(block.Header.PruningPoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
header := blockheader.NewImmutableBlockHeader(
|
|
uint16(block.Header.Version),
|
|
parents,
|
|
hashMerkleRoot,
|
|
acceptedIDMerkleRoot,
|
|
utxoCommitment,
|
|
block.Header.Timestamp,
|
|
block.Header.Bits,
|
|
block.Header.Nonce,
|
|
block.Header.DAAScore,
|
|
block.Header.BlueScore,
|
|
blueWork,
|
|
pruningPoint)
|
|
transactions := make([]*externalapi.DomainTransaction, len(block.Transactions))
|
|
for i, transaction := range block.Transactions {
|
|
domainTransaction, err := RPCTransactionToDomainTransaction(transaction)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
transactions[i] = domainTransaction
|
|
}
|
|
return &externalapi.DomainBlock{
|
|
Header: header,
|
|
Transactions: transactions,
|
|
}, nil
|
|
}
|
|
|
|
// BlockWithTrustedDataToDomainBlockWithTrustedData converts *MsgBlockWithTrustedData to *externalapi.BlockWithTrustedData
|
|
func BlockWithTrustedDataToDomainBlockWithTrustedData(block *MsgBlockWithTrustedData) *externalapi.BlockWithTrustedData {
|
|
daaWindow := make([]*externalapi.TrustedDataDataDAAHeader, len(block.DAAWindow))
|
|
for i, daaBlock := range block.DAAWindow {
|
|
daaWindow[i] = &externalapi.TrustedDataDataDAAHeader{
|
|
Header: BlockHeaderToDomainBlockHeader(&daaBlock.Block.Header),
|
|
GHOSTDAGData: ghostdagDataToDomainGHOSTDAGData(daaBlock.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
ghostdagData := make([]*externalapi.BlockGHOSTDAGDataHashPair, len(block.GHOSTDAGData))
|
|
for i, datum := range block.GHOSTDAGData {
|
|
ghostdagData[i] = &externalapi.BlockGHOSTDAGDataHashPair{
|
|
Hash: datum.Hash,
|
|
GHOSTDAGData: ghostdagDataToDomainGHOSTDAGData(datum.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
return &externalapi.BlockWithTrustedData{
|
|
Block: MsgBlockToDomainBlock(block.Block),
|
|
DAAWindow: daaWindow,
|
|
GHOSTDAGData: ghostdagData,
|
|
}
|
|
}
|
|
|
|
// TrustedDataDataDAABlockV4ToTrustedDataDataDAAHeader converts *TrustedDataDAAHeader to *externalapi.TrustedDataDataDAAHeader
|
|
func TrustedDataDataDAABlockV4ToTrustedDataDataDAAHeader(daaBlock *TrustedDataDAAHeader) *externalapi.TrustedDataDataDAAHeader {
|
|
return &externalapi.TrustedDataDataDAAHeader{
|
|
Header: BlockHeaderToDomainBlockHeader(daaBlock.Header),
|
|
GHOSTDAGData: ghostdagDataToDomainGHOSTDAGData(daaBlock.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
// GHOSTDAGHashPairToDomainGHOSTDAGHashPair converts *BlockGHOSTDAGDataHashPair to *externalapi.BlockGHOSTDAGDataHashPair
|
|
func GHOSTDAGHashPairToDomainGHOSTDAGHashPair(datum *BlockGHOSTDAGDataHashPair) *externalapi.BlockGHOSTDAGDataHashPair {
|
|
return &externalapi.BlockGHOSTDAGDataHashPair{
|
|
Hash: datum.Hash,
|
|
GHOSTDAGData: ghostdagDataToDomainGHOSTDAGData(datum.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
func ghostdagDataToDomainGHOSTDAGData(data *BlockGHOSTDAGData) *externalapi.BlockGHOSTDAGData {
|
|
bluesAnticoneSizes := make(map[externalapi.DomainHash]externalapi.KType, len(data.BluesAnticoneSizes))
|
|
for _, pair := range data.BluesAnticoneSizes {
|
|
bluesAnticoneSizes[*pair.BlueHash] = pair.AnticoneSize
|
|
}
|
|
return externalapi.NewBlockGHOSTDAGData(
|
|
data.BlueScore,
|
|
data.BlueWork,
|
|
data.SelectedParent,
|
|
data.MergeSetBlues,
|
|
data.MergeSetReds,
|
|
bluesAnticoneSizes,
|
|
)
|
|
}
|
|
|
|
func domainGHOSTDAGDataGHOSTDAGData(data *externalapi.BlockGHOSTDAGData) *BlockGHOSTDAGData {
|
|
bluesAnticoneSizes := make([]*BluesAnticoneSizes, 0, len(data.BluesAnticoneSizes()))
|
|
for blueHash, anticoneSize := range data.BluesAnticoneSizes() {
|
|
blueHashCopy := blueHash
|
|
bluesAnticoneSizes = append(bluesAnticoneSizes, &BluesAnticoneSizes{
|
|
BlueHash: &blueHashCopy,
|
|
AnticoneSize: anticoneSize,
|
|
})
|
|
}
|
|
|
|
return &BlockGHOSTDAGData{
|
|
BlueScore: data.BlueScore(),
|
|
BlueWork: data.BlueWork(),
|
|
SelectedParent: data.SelectedParent(),
|
|
MergeSetBlues: data.MergeSetBlues(),
|
|
MergeSetReds: data.MergeSetReds(),
|
|
BluesAnticoneSizes: bluesAnticoneSizes,
|
|
}
|
|
}
|
|
|
|
// DomainBlockWithTrustedDataToBlockWithTrustedData converts *externalapi.BlockWithTrustedData to *MsgBlockWithTrustedData
|
|
func DomainBlockWithTrustedDataToBlockWithTrustedData(block *externalapi.BlockWithTrustedData) *MsgBlockWithTrustedData {
|
|
daaWindow := make([]*TrustedDataDataDAABlock, len(block.DAAWindow))
|
|
for i, daaBlock := range block.DAAWindow {
|
|
daaWindow[i] = &TrustedDataDataDAABlock{
|
|
Block: &MsgBlock{
|
|
Header: *DomainBlockHeaderToBlockHeader(daaBlock.Header),
|
|
},
|
|
GHOSTDAGData: domainGHOSTDAGDataGHOSTDAGData(daaBlock.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
ghostdagData := make([]*BlockGHOSTDAGDataHashPair, len(block.GHOSTDAGData))
|
|
for i, datum := range block.GHOSTDAGData {
|
|
ghostdagData[i] = &BlockGHOSTDAGDataHashPair{
|
|
Hash: datum.Hash,
|
|
GHOSTDAGData: domainGHOSTDAGDataGHOSTDAGData(datum.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
return &MsgBlockWithTrustedData{
|
|
Block: DomainBlockToMsgBlock(block.Block),
|
|
DAAScore: block.Block.Header.DAAScore(),
|
|
DAAWindow: daaWindow,
|
|
GHOSTDAGData: ghostdagData,
|
|
}
|
|
}
|
|
|
|
// DomainBlockWithTrustedDataToBlockWithTrustedDataV4 converts a set of *externalapi.DomainBlock, daa window indices and ghostdag data indices
|
|
// to *MsgBlockWithTrustedDataV4
|
|
func DomainBlockWithTrustedDataToBlockWithTrustedDataV4(block *externalapi.DomainBlock, daaWindowIndices, ghostdagDataIndices []uint64) *MsgBlockWithTrustedDataV4 {
|
|
return &MsgBlockWithTrustedDataV4{
|
|
Block: DomainBlockToMsgBlock(block),
|
|
DAAWindowIndices: daaWindowIndices,
|
|
GHOSTDAGDataIndices: ghostdagDataIndices,
|
|
}
|
|
}
|
|
|
|
// DomainTrustedDataToTrustedData converts *externalapi.BlockWithTrustedData to *MsgBlockWithTrustedData
|
|
func DomainTrustedDataToTrustedData(domainDAAWindow []*externalapi.TrustedDataDataDAAHeader, domainGHOSTDAGData []*externalapi.BlockGHOSTDAGDataHashPair) *MsgTrustedData {
|
|
daaWindow := make([]*TrustedDataDAAHeader, len(domainDAAWindow))
|
|
for i, daaBlock := range domainDAAWindow {
|
|
daaWindow[i] = &TrustedDataDAAHeader{
|
|
Header: DomainBlockHeaderToBlockHeader(daaBlock.Header),
|
|
GHOSTDAGData: domainGHOSTDAGDataGHOSTDAGData(daaBlock.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
ghostdagData := make([]*BlockGHOSTDAGDataHashPair, len(domainGHOSTDAGData))
|
|
for i, datum := range domainGHOSTDAGData {
|
|
ghostdagData[i] = &BlockGHOSTDAGDataHashPair{
|
|
Hash: datum.Hash,
|
|
GHOSTDAGData: domainGHOSTDAGDataGHOSTDAGData(datum.GHOSTDAGData),
|
|
}
|
|
}
|
|
|
|
return &MsgTrustedData{
|
|
DAAWindow: daaWindow,
|
|
GHOSTDAGData: ghostdagData,
|
|
}
|
|
}
|
|
|
|
// MsgPruningPointProofToDomainPruningPointProof converts *MsgPruningPointProof to *externalapi.PruningPointProof
|
|
func MsgPruningPointProofToDomainPruningPointProof(pruningPointProofMessage *MsgPruningPointProof) *externalapi.PruningPointProof {
|
|
headers := make([][]externalapi.BlockHeader, len(pruningPointProofMessage.Headers))
|
|
for blockLevel, blockLevelParents := range pruningPointProofMessage.Headers {
|
|
headers[blockLevel] = make([]externalapi.BlockHeader, len(blockLevelParents))
|
|
for i, header := range blockLevelParents {
|
|
headers[blockLevel][i] = BlockHeaderToDomainBlockHeader(header)
|
|
}
|
|
}
|
|
return &externalapi.PruningPointProof{
|
|
Headers: headers,
|
|
}
|
|
}
|
|
|
|
// DomainPruningPointProofToMsgPruningPointProof converts *externalapi.PruningPointProof to *MsgPruningPointProof
|
|
func DomainPruningPointProofToMsgPruningPointProof(pruningPointProof *externalapi.PruningPointProof) *MsgPruningPointProof {
|
|
headers := make([][]*MsgBlockHeader, len(pruningPointProof.Headers))
|
|
for blockLevel, blockLevelParents := range pruningPointProof.Headers {
|
|
headers[blockLevel] = make([]*MsgBlockHeader, len(blockLevelParents))
|
|
for i, header := range blockLevelParents {
|
|
headers[blockLevel][i] = DomainBlockHeaderToBlockHeader(header)
|
|
}
|
|
}
|
|
return &MsgPruningPointProof{
|
|
Headers: headers,
|
|
}
|
|
}
|