9 "github.com/bytom/bytom/account"
10 "github.com/bytom/bytom/asset"
11 "github.com/bytom/bytom/blockchain/pseudohsm"
12 "github.com/bytom/bytom/blockchain/signers"
13 "github.com/bytom/bytom/blockchain/txbuilder"
14 "github.com/bytom/bytom/common"
15 "github.com/bytom/bytom/consensus"
16 "github.com/bytom/bytom/crypto/ed25519/chainkd"
17 "github.com/bytom/bytom/crypto/sha3pool"
18 dbm "github.com/bytom/bytom/database/leveldb"
19 "github.com/bytom/bytom/errors"
20 "github.com/bytom/bytom/protocol/bc"
21 "github.com/bytom/bytom/protocol/bc/types"
22 "github.com/bytom/bytom/protocol/vm"
23 "github.com/bytom/bytom/protocol/vm/vmutil"
26 // TxGenerator used to generate new tx
27 type TxGenerator struct {
28 Builder *txbuilder.TemplateBuilder
29 AccountManager *account.Manager
30 Assets *asset.Registry
34 // NewTxGenerator create a TxGenerator
35 func NewTxGenerator(accountManager *account.Manager, assets *asset.Registry, hsm *pseudohsm.HSM) *TxGenerator {
37 Builder: txbuilder.NewBuilder(time.Now()),
38 AccountManager: accountManager,
44 // Reset reset transaction builder, used to create a new tx
45 func (g *TxGenerator) Reset() {
46 g.Builder = txbuilder.NewBuilder(time.Now())
49 func (g *TxGenerator) createKey(alias string, auth string) error {
50 _, _, err := g.Hsm.XCreate(alias, auth, "en")
54 func (g *TxGenerator) getPubkey(keyAlias string) *chainkd.XPub {
55 pubKeys := g.Hsm.ListKeys()
56 for i, key := range pubKeys {
57 if key.Alias == keyAlias {
58 return &pubKeys[i].XPub
64 func (g *TxGenerator) createAccount(name string, keys []string, quorum int) error {
65 xpubs := []chainkd.XPub{}
66 for _, alias := range keys {
67 xpub := g.getPubkey(alias)
69 return fmt.Errorf("can't find pubkey for %s", alias)
71 xpubs = append(xpubs, *xpub)
73 _, err := g.AccountManager.Create(xpubs, quorum, name, signers.BIP0044)
77 func (g *TxGenerator) createAsset(accountAlias string, assetAlias string) (*asset.Asset, error) {
78 acc, err := g.AccountManager.FindByAlias(accountAlias)
82 return g.Assets.Define(acc.XPubs, len(acc.XPubs), nil, 0, assetAlias, nil)
85 func (g *TxGenerator) mockUtxo(accountAlias, assetAlias string, amount uint64) (*account.UTXO, error) {
86 ctrlProg, err := g.createControlProgram(accountAlias, false)
91 assetAmount, err := g.assetAmount(assetAlias, amount)
95 utxo := &account.UTXO{
96 OutputID: bc.Hash{V0: 1},
97 SourceID: bc.Hash{V0: 1},
98 AssetID: *assetAmount.AssetId,
99 Amount: assetAmount.Amount,
101 ControlProgram: ctrlProg.ControlProgram,
102 ControlProgramIndex: ctrlProg.KeyIndex,
103 AccountID: ctrlProg.AccountID,
104 Address: ctrlProg.Address,
106 Change: ctrlProg.Change,
111 func (g *TxGenerator) assetAmount(assetAlias string, amount uint64) (*bc.AssetAmount, error) {
112 if assetAlias == "BTM" {
113 a := &bc.AssetAmount{
115 AssetId: consensus.BTMAssetID,
120 asset, err := g.Assets.FindByAlias(assetAlias)
124 return &bc.AssetAmount{
126 AssetId: &asset.AssetID,
130 func (g *TxGenerator) createControlProgram(accountAlias string, change bool) (*account.CtrlProgram, error) {
131 acc, err := g.AccountManager.FindByAlias(accountAlias)
135 return g.AccountManager.CreateAddress(acc.ID, change)
138 // AddSpendInput add a spend input
139 func (g *TxGenerator) AddSpendInput(accountAlias, assetAlias string, amount uint64) error {
140 assetAmount, err := g.assetAmount(assetAlias, amount)
145 acc, err := g.AccountManager.FindByAlias(accountAlias)
150 reqAction := make(map[string]interface{})
151 reqAction["account_id"] = acc.ID
152 reqAction["amount"] = amount
153 reqAction["asset_id"] = assetAmount.AssetId.String()
154 data, err := json.Marshal(reqAction)
159 spendAction, err := g.AccountManager.DecodeSpendAction(data)
163 return spendAction.Build(nil, g.Builder)
166 // AddTxInput add a tx input and signing instruction
167 func (g *TxGenerator) AddTxInput(txInput *types.TxInput, signInstruction *txbuilder.SigningInstruction) error {
168 return g.Builder.AddInput(txInput, signInstruction)
171 // AddTxInputFromUtxo add a tx input which spent the utxo
172 func (g *TxGenerator) AddTxInputFromUtxo(utxo *account.UTXO, accountAlias string) error {
173 acc, err := g.AccountManager.FindByAlias(accountAlias)
178 txInput, signInst, err := account.UtxoToInputs(acc.Signer, utxo)
182 return g.AddTxInput(txInput, signInst)
185 // AddIssuanceInput add a issue input
186 func (g *TxGenerator) AddIssuanceInput(assetAlias string, amount uint64) error {
187 asset, err := g.Assets.FindByAlias(assetAlias)
193 _, err = rand.Read(nonce[:])
197 issuanceInput := types.NewIssuanceInput(nonce[:], amount, asset.IssuanceProgram, nil, asset.RawDefinitionByte)
198 signInstruction := &txbuilder.SigningInstruction{}
199 path := signers.GetBip0032Path(asset.Signer, signers.AssetKeySpace)
200 signInstruction.AddRawWitnessKeys(asset.Signer.XPubs, path, asset.Signer.Quorum)
201 g.Builder.RestrictMinTime(time.Now())
202 return g.Builder.AddInput(issuanceInput, signInstruction)
205 // AddTxOutput add a tx output
206 func (g *TxGenerator) AddTxOutput(accountAlias, assetAlias string, amount uint64) error {
207 assetAmount, err := g.assetAmount(assetAlias, uint64(amount))
211 controlProgram, err := g.createControlProgram(accountAlias, false)
215 out := types.NewTxOutput(*assetAmount.AssetId, assetAmount.Amount, controlProgram.ControlProgram)
216 return g.Builder.AddOutput(out)
219 // AddRetirement add a retirement output
220 func (g *TxGenerator) AddRetirement(assetAlias string, amount uint64) error {
221 assetAmount, err := g.assetAmount(assetAlias, uint64(amount))
225 retirementProgram := []byte{byte(vm.OP_FAIL)}
226 out := types.NewTxOutput(*assetAmount.AssetId, assetAmount.Amount, retirementProgram)
227 return g.Builder.AddOutput(out)
230 // Sign used to sign tx
231 func (g *TxGenerator) Sign(passwords []string) (*types.Tx, error) {
232 tpl, _, err := g.Builder.Build()
237 txSerialized, err := tpl.Transaction.MarshalText()
242 tpl.Transaction.Tx.SerializedSize = uint64(len(txSerialized))
243 tpl.Transaction.TxData.SerializedSize = uint64(len(txSerialized))
244 for _, password := range passwords {
245 _, err = MockSign(tpl, g.Hsm, password)
250 return tpl.Transaction, nil
253 func txFee(tx *types.Tx) uint64 {
254 if len(tx.Inputs) == 1 && tx.Inputs[0].InputType() == types.CoinbaseInputType {
258 inputSum := uint64(0)
259 outputSum := uint64(0)
260 for _, input := range tx.Inputs {
261 if input.AssetID() == *consensus.BTMAssetID {
262 inputSum += input.Amount()
266 for _, output := range tx.Outputs {
267 if *output.AssetId == *consensus.BTMAssetID {
268 outputSum += output.Amount
271 return inputSum - outputSum
274 // CreateSpendInput create SpendInput which spent the output from tx
275 func CreateSpendInput(tx *types.Tx, outputIndex uint64) (*types.SpendInput, error) {
276 outputID := tx.ResultIds[outputIndex]
277 output, ok := tx.Entries[*outputID].(*bc.Output)
279 return nil, fmt.Errorf("retirement can't be spent")
282 sc := types.SpendCommitment{
283 AssetAmount: *output.Source.Value,
284 SourceID: *output.Source.Ref,
285 SourcePosition: output.Ordinal,
286 VMVersion: vmVersion,
287 ControlProgram: output.ControlProgram.Code,
289 return &types.SpendInput{
294 // SignInstructionFor read CtrlProgram from db, construct SignInstruction for SpendInput
295 func SignInstructionFor(input *types.SpendInput, db dbm.DB, signer *signers.Signer) (*txbuilder.SigningInstruction, error) {
296 cp := account.CtrlProgram{}
298 sha3pool.Sum256(hash[:], input.ControlProgram)
299 bytes := db.Get(account.ContractKey(hash))
301 return nil, fmt.Errorf("can't find CtrlProgram for the SpendInput")
304 err := json.Unmarshal(bytes, &cp)
309 sigInst := &txbuilder.SigningInstruction{}
314 // FIXME: code duplicate with account/builder.go
315 path, err := signers.Path(signer, signers.AccountKeySpace, cp.Change, cp.KeyIndex)
320 if cp.Address == "" {
321 sigInst.AddWitnessKeys(signer.XPubs, path, signer.Quorum)
325 address, err := common.DecodeAddress(cp.Address, &consensus.MainNetParams)
330 switch address.(type) {
331 case *common.AddressWitnessPubKeyHash:
332 sigInst.AddRawWitnessKeys(signer.XPubs, path, signer.Quorum)
333 derivedXPubs := chainkd.DeriveXPubs(signer.XPubs, path)
334 derivedPK := derivedXPubs[0].PublicKey()
335 sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness([]byte(derivedPK)))
337 case *common.AddressWitnessScriptHash:
338 sigInst.AddRawWitnessKeys(signer.XPubs, path, signer.Quorum)
339 path, err := signers.Path(signer, signers.AccountKeySpace, cp.Change, cp.KeyIndex)
343 derivedXPubs := chainkd.DeriveXPubs(signer.XPubs, path)
344 derivedPKs := chainkd.XPubKeys(derivedXPubs)
345 script, err := vmutil.P2SPMultiSigProgram(derivedPKs, signer.Quorum)
349 sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness(script))
352 return nil, errors.New("unsupport address type")
358 // CreateCoinbaseTx create coinbase tx at block height
359 func CreateCoinbaseTx(controlProgram []byte, height, txsFee uint64) (*types.Tx, error) {
360 coinbaseValue := consensus.BlockSubsidy(height) + txsFee
361 builder := txbuilder.NewBuilder(time.Now())
362 if err := builder.AddInput(types.NewCoinbaseInput([]byte(fmt.Sprint(height))), &txbuilder.SigningInstruction{}); err != nil {
365 if err := builder.AddOutput(types.NewTxOutput(*consensus.BTMAssetID, coinbaseValue, controlProgram)); err != nil {
369 tpl, _, err := builder.Build()
374 txSerialized, err := tpl.Transaction.MarshalText()
379 tpl.Transaction.Tx.SerializedSize = uint64(len(txSerialized))
380 tpl.Transaction.TxData.SerializedSize = uint64(len(txSerialized))
381 return tpl.Transaction, nil
384 // CreateTxFromTx create a tx spent the output in outputIndex at baseTx
385 func CreateTxFromTx(baseTx *types.Tx, outputIndex uint64, outputAmount uint64, ctrlProgram []byte) (*types.Tx, error) {
386 spendInput, err := CreateSpendInput(baseTx, outputIndex)
391 txInput := &types.TxInput{
392 AssetVersion: assetVersion,
393 TypedInput: spendInput,
395 output := types.NewTxOutput(*consensus.BTMAssetID, outputAmount, ctrlProgram)
396 builder := txbuilder.NewBuilder(time.Now())
397 if err := builder.AddInput(txInput, &txbuilder.SigningInstruction{}); err != nil {
400 if err := builder.AddOutput(output); err != nil {
404 tpl, _, err := builder.Build()
409 txSerialized, err := tpl.Transaction.MarshalText()
414 tpl.Transaction.Tx.SerializedSize = uint64(len(txSerialized))
415 tpl.Transaction.TxData.SerializedSize = uint64(len(txSerialized))
416 return tpl.Transaction, nil