Bytom交易说明（UTXO用户自己管理模式）

utxo

utxo

input

output

1.创建私钥和公钥

NewXKeys(nil)

func NewXKeys(r io.Reader) (xprv XPrv, xpub XPub, err error) {
xprv, err = NewXPrv(r)
if err != nil {
return
}
return xprv, xprv.XPub(), nil
}

2.根据公钥创建接收对象

address

program

func (m *Manager) createP2PKH(xpub chainkd.XPub) (*CtrlProgram, error) {
pubKey := xpub.PublicKey()
pubHash := crypto.Ripemd160(pubKey)

// TODO: pass different params due to config
address, err := common.NewAddressWitnessPubKeyHash(pubHash, &consensus.ActiveNetParams)
if err != nil {
return nil, err
}

control, err := vmutil.P2WPKHProgram([]byte(pubHash))
if err != nil {
return nil, err
}

return &CtrlProgram{
Address:        address.EncodeAddress(),
ControlProgram: control,
}, nil
}

func (m *Manager) createP2SH(xpubs []chainkd.XPub) (*CtrlProgram, error) {
derivedPKs := chainkd.XPubKeys(xpubs)
signScript, err := vmutil.P2SPMultiSigProgram(derivedPKs, len(derivedPKs))
if err != nil {
return nil, err
}
scriptHash := crypto.Sha256(signScript)

// TODO: pass different params due to config
address, err := common.NewAddressWitnessScriptHash(scriptHash, &consensus.ActiveNetParams)
if err != nil {
return nil, err
}

control, err := vmutil.P2WSHProgram(scriptHash)
if err != nil {
return nil, err
}

return &CtrlProgram{
Address:        address.EncodeAddress(),
ControlProgram: control,
}, nil
}

3.找到可花费的utxo

program

unspend_output

// UTXO describes an individual account utxo.
type UTXO struct {
OutputID bc.Hash
SourceID bc.Hash

// Avoiding AssetAmount here so that new(utxo) doesn't produce an
// AssetAmount with a nil AssetId.
AssetID bc.AssetID
Amount  uint64

SourcePos      uint64
ControlProgram []byte

AccountID           string
Address             string
ControlProgramIndex uint64
ValidHeight         uint64
Change              bool
}

SourceID

AssetID

Amount

SourcePos

ControlProgram

Address

get-block

// BlockTx is the tx struct for getBlock func
type BlockTx struct {
ID         bc.Hash                  `json:"id"`
Version    uint64                   `json:"version"`
Size       uint64                   `json:"size"`
TimeRange  uint64                   `json:"time_range"`
Inputs     []*query.AnnotatedInput  `json:"inputs"`
Outputs    []*query.AnnotatedOutput `json:"outputs"`
StatusFail bool                     `json:"status_fail"`
MuxID      bc.Hash                  `json:"mux_id"`
}

//AnnotatedOutput means an annotated transaction output.
type AnnotatedOutput struct {
Type            string             `json:"type"`
OutputID        bc.Hash            `json:"id"`
TransactionID   *bc.Hash           `json:"transaction_id,omitempty"`
Position        int                `json:"position"`
AssetID         bc.AssetID         `json:"asset_id"`
AssetAlias      string             `json:"asset_alias,omitempty"`
AssetDefinition *json.RawMessage   `json:"asset_definition,omitempty"`
Amount          uint64             `json:"amount"`
AccountID       string             `json:"account_id,omitempty"`
AccountAlias    string             `json:"account_alias,omitempty"`
ControlProgram  chainjson.HexBytes `json:"control_program"`
Address         string             `json:"address,omitempty"`
}

`SourceID`       - `json:"mux_id"`
`AssetID`        - `json:"asset_id"`
`Amount`         - `json:"amount"`
`SourcePos`      - `json:"position"`
`ControlProgram` - `json:"control_program"`
`Address`        - `json:"address,omitempty"`

4.通过

utxo

构造交易

utxo

TxInput

SigningInstruction

// UtxoToInputs convert an utxo to the txinput
func UtxoToInputs(xpubs []chainkd.XPub, u *UTXO) (*types.TxInput, *txbuilder.SigningInstruction, error) {
txInput := types.NewSpendInput(nil, u.SourceID, u.AssetID, u.Amount, u.SourcePos, u.ControlProgram)
sigInst := &txbuilder.SigningInstruction{}

if u.Address == "" {
return txInput, sigInst, nil
}

address, err := common.DecodeAddress(u.Address, &consensus.ActiveNetParams)
if err != nil {
return nil, nil, err
}

switch address.(type) {
case *common.AddressWitnessPubKeyHash:
derivedPK := xpubs[0].PublicKey()
sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness([]byte(derivedPK)))

case *common.AddressWitnessScriptHash:
derivedPKs := chainkd.XPubKeys(xpubs)
script, err := vmutil.P2SPMultiSigProgram(derivedPKs, len(derivedPKs))
if err != nil {
return nil, nil, err
}
sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness(script))

default:
return nil, nil, errors.New("unsupport address type")
}

return txInput, sigInst, nil
}

utxo

TxOutput

// NewTxOutput create a new output struct
func NewTxOutput(assetID bc.AssetID, amount uint64, controlProgram []byte) *TxOutput {
return &TxOutput{
AssetVersion: 1,
OutputCommitment: OutputCommitment{
AssetAmount: bc.AssetAmount{
AssetId: &assetID,
Amount:  amount,
},
VMVersion:      1,
ControlProgram: controlProgram,
},
}
}

5.组合交易的input和output构成交易模板

txbuilder.Template

type InputAndSigInst struct {
input *types.TxInput
sigInst *SigningInstruction
}

// Build build transactions with template
func BuildTx(inputs []InputAndSigInst, outputs []*types.TxOutput) (*Template, *types.TxData, error) {
tpl := &Template{}
tx := &types.TxData{}
// Add all the built outputs.
tx.Outputs = append(tx.Outputs, outputs...)

// Add all the built inputs and their corresponding signing instructions.
for _, in := range inputs {
// Empty signature arrays should be serialized as empty arrays, not null.
in.sigInst.Position = uint32(len(inputs))
if in.sigInst.WitnessComponents == nil {
in.sigInst.WitnessComponents = []witnessComponent{}
}
tpl.SigningInstructions = append(tpl.SigningInstructions, in.sigInst)
tx.Inputs = append(tx.Inputs, in.input)
}

tpl.Transaction = types.NewTx(*tx)
return tpl, tx, nil
}

6.对构造的交易进行签名

// Sign will try to sign all the witness
func Sign(tpl *Template, xprv chainkd.XPrv) error {
for i, sigInst := range tpl.SigningInstructions {
h := tpl.Hash(uint32(i)).Byte32()
sig := xprv.Sign(h[:])
rawTxSig := &RawTxSigWitness{
Quorum: 1,
Sigs:   []json.HexBytes{sig},
}
sigInst.WitnessComponents = append([]witnessComponent(rawTxSig), sigInst.WitnessComponents...)
}
return materializeWitnesses(tpl)
}

7.提交交易上链