8 "github.com/vapor/account"
9 "github.com/vapor/asset"
10 "github.com/vapor/blockchain/pseudohsm"
11 "github.com/vapor/blockchain/signers"
12 "github.com/vapor/blockchain/txbuilder"
13 "github.com/vapor/common"
14 "github.com/vapor/consensus"
15 "github.com/vapor/crypto/ed25519/chainkd"
16 "github.com/vapor/crypto/sha3pool"
17 "github.com/vapor/database"
18 dbm "github.com/vapor/database/leveldb"
19 "github.com/vapor/errors"
20 "github.com/vapor/protocol/bc"
21 "github.com/vapor/protocol/bc/types"
22 "github.com/vapor/protocol/vm"
23 "github.com/vapor/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) mockUtxo(accountAlias, assetAlias string, amount uint64) (*account.UTXO, error) {
78 ctrlProg, err := g.createControlProgram(accountAlias, false)
83 assetAmount, err := g.assetAmount(assetAlias, amount)
87 utxo := &account.UTXO{
88 OutputID: bc.Hash{V0: 1},
89 SourceID: bc.Hash{V0: 1},
90 AssetID: *assetAmount.AssetId,
91 Amount: assetAmount.Amount,
93 ControlProgram: ctrlProg.ControlProgram,
94 ControlProgramIndex: ctrlProg.KeyIndex,
95 AccountID: ctrlProg.AccountID,
96 Address: ctrlProg.Address,
98 Change: ctrlProg.Change,
103 func (g *TxGenerator) assetAmount(assetAlias string, amount uint64) (*bc.AssetAmount, error) {
104 if assetAlias == "BTM" {
105 a := &bc.AssetAmount{
107 AssetId: consensus.BTMAssetID,
112 asset, err := g.Assets.FindByAlias(assetAlias)
116 return &bc.AssetAmount{
118 AssetId: &asset.AssetID,
122 func (g *TxGenerator) createControlProgram(accountAlias string, change bool) (*account.CtrlProgram, error) {
123 acc, err := g.AccountManager.FindByAlias(accountAlias)
127 return g.AccountManager.CreateAddress(acc.ID, change)
130 // AddSpendInput add a spend input
131 func (g *TxGenerator) AddSpendInput(accountAlias, assetAlias string, amount uint64) error {
132 assetAmount, err := g.assetAmount(assetAlias, amount)
137 acc, err := g.AccountManager.FindByAlias(accountAlias)
142 reqAction := make(map[string]interface{})
143 reqAction["account_id"] = acc.ID
144 reqAction["amount"] = amount
145 reqAction["asset_id"] = assetAmount.AssetId.String()
146 data, err := json.Marshal(reqAction)
151 spendAction, err := g.AccountManager.DecodeSpendAction(data)
155 return spendAction.Build(nil, g.Builder)
158 // AddTxInput add a tx input and signing instruction
159 func (g *TxGenerator) AddTxInput(txInput *types.TxInput, signInstruction *txbuilder.SigningInstruction) error {
160 return g.Builder.AddInput(txInput, signInstruction)
163 // AddTxInputFromUtxo add a tx input which spent the utxo
164 func (g *TxGenerator) AddTxInputFromUtxo(utxo *account.UTXO, accountAlias string) error {
165 acc, err := g.AccountManager.FindByAlias(accountAlias)
170 txInput, signInst, err := account.UtxoToInputs(acc.Signer, utxo)
174 return g.AddTxInput(txInput, signInst)
177 // AddTxOutput add a tx output
178 func (g *TxGenerator) AddTxOutput(accountAlias, assetAlias string, amount uint64) error {
179 assetAmount, err := g.assetAmount(assetAlias, uint64(amount))
183 controlProgram, err := g.createControlProgram(accountAlias, false)
187 out := types.NewIntraChainOutput(*assetAmount.AssetId, assetAmount.Amount, controlProgram.ControlProgram)
188 return g.Builder.AddOutput(out)
191 // AddRetirement add a retirement output
192 func (g *TxGenerator) AddRetirement(assetAlias string, amount uint64) error {
193 assetAmount, err := g.assetAmount(assetAlias, uint64(amount))
197 retirementProgram := []byte{byte(vm.OP_FAIL)}
198 out := types.NewIntraChainOutput(*assetAmount.AssetId, assetAmount.Amount, retirementProgram)
199 return g.Builder.AddOutput(out)
202 // Sign used to sign tx
203 func (g *TxGenerator) Sign(passwords []string) (*types.Tx, error) {
204 tpl, _, err := g.Builder.Build()
209 txSerialized, err := tpl.Transaction.MarshalText()
214 tpl.Transaction.Tx.SerializedSize = uint64(len(txSerialized))
215 tpl.Transaction.TxData.SerializedSize = uint64(len(txSerialized))
216 for _, password := range passwords {
217 _, err = MockSign(tpl, g.Hsm, password)
222 return tpl.Transaction, nil
225 func txFee(tx *types.Tx) uint64 {
226 if len(tx.Inputs) == 1 && tx.Inputs[0].InputType() == types.CoinbaseInputType {
230 inputSum := uint64(0)
231 outputSum := uint64(0)
232 for _, input := range tx.Inputs {
233 if input.AssetID() == *consensus.BTMAssetID {
234 inputSum += input.Amount()
238 for _, output := range tx.Outputs {
239 if *output.AssetAmount().AssetId == *consensus.BTMAssetID {
240 outputSum += output.AssetAmount().Amount
243 return inputSum - outputSum
246 // CreateSpendInput create SpendInput which spent the output from tx
247 func CreateSpendInput(tx *types.Tx, outputIndex uint64) (*types.SpendInput, error) {
248 outputID := tx.ResultIds[outputIndex]
249 output, ok := tx.Entries[*outputID].(*bc.IntraChainOutput)
251 return nil, fmt.Errorf("retirement can't be spent")
254 sc := types.SpendCommitment{
255 AssetAmount: *output.Source.Value,
256 SourceID: *output.Source.Ref,
257 SourcePosition: output.Ordinal,
258 VMVersion: vmVersion,
259 ControlProgram: output.ControlProgram.Code,
261 return &types.SpendInput{
266 // SignInstructionFor read CtrlProgram from db, construct SignInstruction for SpendInput
267 func SignInstructionFor(input *types.SpendInput, db dbm.DB, signer *signers.Signer) (*txbuilder.SigningInstruction, error) {
268 cp := account.CtrlProgram{}
270 sha3pool.Sum256(hash[:], input.ControlProgram)
271 bytes := db.Get(database.ContractKey(bc.NewHash(hash)))
273 return nil, fmt.Errorf("can't find CtrlProgram for the SpendInput")
276 err := json.Unmarshal(bytes, &cp)
281 sigInst := &txbuilder.SigningInstruction{}
286 // FIXME: code duplicate with account/builder.go
287 path, err := signers.Path(signer, signers.AccountKeySpace, cp.Change, cp.KeyIndex)
292 if cp.Address == "" {
293 sigInst.AddWitnessKeys(signer.XPubs, path, signer.Quorum)
297 address, err := common.DecodeAddress(cp.Address, &consensus.VaporNetParams)
302 switch address.(type) {
303 case *common.AddressWitnessPubKeyHash:
304 sigInst.AddRawWitnessKeys(signer.XPubs, path, signer.Quorum)
305 derivedXPubs := chainkd.DeriveXPubs(signer.XPubs, path)
306 derivedPK := derivedXPubs[0].PublicKey()
307 sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness([]byte(derivedPK)))
309 case *common.AddressWitnessScriptHash:
310 sigInst.AddRawWitnessKeys(signer.XPubs, path, signer.Quorum)
311 path, err := signers.Path(signer, signers.AccountKeySpace, cp.Change, cp.KeyIndex)
315 derivedXPubs := chainkd.DeriveXPubs(signer.XPubs, path)
316 derivedPKs := chainkd.XPubKeys(derivedXPubs)
317 script, err := vmutil.P2SPMultiSigProgram(derivedPKs, signer.Quorum)
321 sigInst.WitnessComponents = append(sigInst.WitnessComponents, txbuilder.DataWitness(script))
324 return nil, errors.New("unsupport address type")
330 // CreateCoinbaseTx create coinbase tx at block height
331 func CreateCoinbaseTx(controlProgram []byte, height, txsFee uint64) (*types.Tx, error) {
332 coinbaseValue := consensus.BlockSubsidy(height) + txsFee
333 builder := txbuilder.NewBuilder(time.Now())
334 if err := builder.AddInput(types.NewCoinbaseInput([]byte(string(height))), &txbuilder.SigningInstruction{}); err != nil {
337 if err := builder.AddOutput(types.NewIntraChainOutput(*consensus.BTMAssetID, coinbaseValue, controlProgram)); err != nil {
341 tpl, _, err := builder.Build()
346 txSerialized, err := tpl.Transaction.MarshalText()
351 tpl.Transaction.Tx.SerializedSize = uint64(len(txSerialized))
352 tpl.Transaction.TxData.SerializedSize = uint64(len(txSerialized))
353 return tpl.Transaction, nil
356 // CreateTxFromTx create a tx spent the output in outputIndex at baseTx
357 func CreateTxFromTx(baseTx *types.Tx, outputIndex uint64, outputAmount uint64, ctrlProgram []byte) (*types.Tx, error) {
358 spendInput, err := CreateSpendInput(baseTx, outputIndex)
363 txInput := &types.TxInput{
364 AssetVersion: assetVersion,
365 TypedInput: spendInput,
367 output := types.NewIntraChainOutput(*consensus.BTMAssetID, outputAmount, ctrlProgram)
368 builder := txbuilder.NewBuilder(time.Now())
369 if err := builder.AddInput(txInput, &txbuilder.SigningInstruction{}); err != nil {
372 if err := builder.AddOutput(output); err != nil {
376 tpl, _, err := builder.Build()
381 txSerialized, err := tpl.Transaction.MarshalText()
386 tpl.Transaction.Tx.SerializedSize = uint64(len(txSerialized))
387 tpl.Transaction.TxData.SerializedSize = uint64(len(txSerialized))
388 return tpl.Transaction, nil