integration_test/standard_transaction_test.go

   1 package integrationTest
   2
   3 import (
   4         "context"
   5         "io/ioutil"
   6         "os"
   7         "testing"
   8         "time"
   9
  10         dbm "github.com/tendermint/tmlibs/db"
  11
  12         "github.com/bytom/blockchain/account"
  13         "github.com/bytom/blockchain/pseudohsm"
  14         "github.com/bytom/blockchain/txbuilder"
  15         "github.com/bytom/blockchain/txdb"
  16         "github.com/bytom/consensus"
  17         "github.com/bytom/crypto/ed25519/chainkd"
  18         "github.com/bytom/protocol"
  19         "github.com/bytom/protocol/bc"
  20         "github.com/bytom/protocol/bc/legacy"
  21         "github.com/bytom/protocol/validation"
  22         "github.com/bytom/protocol/vm"
  23 )
  24
  25 func TestP2PKH(t *testing.T) {
  26         dirPath, err := ioutil.TempDir(".", "")
  27         if err != nil {
  28                 t.Fatal(err)
  29         }
  30         defer os.RemoveAll(dirPath)
  31
  32         testDB := dbm.NewDB("testdb", "leveldb", "temp")
  33         defer os.RemoveAll("temp")
  34
  35         chain, err := mockChain(testDB)
  36         if err != nil {
  37                 t.Fatal(err)
  38         }
  39
  40         accountManager := account.NewManager(testDB, chain)
  41         hsm, err := pseudohsm.New(dirPath)
  42         if err != nil {
  43                 t.Fatal(err)
  44         }
  45
  46         xpub, err := hsm.XCreate("test_pub", "password")
  47         if err != nil {
  48                 t.Fatal(err)
  49         }
  50
  51         testAccount, err := accountManager.Create(nil, []chainkd.XPub{xpub.XPub}, 1, "testAccount", nil, "")
  52         if err != nil {
  53                 t.Fatal(err)
  54         }
  55
  56         controlProg, err := accountManager.CreateP2PKH(nil, testAccount.Signer.ID, false, time.Now())
  57         if err != nil {
  58                 t.Fatal(err)
  59         }
  60
  61         utxo := &account.UTXO{}
  62         utxo.OutputID = bc.Hash{V0: 1}
  63         utxo.SourceID = bc.Hash{V0: 2}
  64         utxo.AssetID = *consensus.BTMAssetID
  65         utxo.Amount = 1000000000
  66         utxo.SourcePos = 0
  67         utxo.ControlProgram = controlProg.ControlProgram
  68         utxo.AccountID = controlProg.AccountID
  69         utxo.Address = controlProg.Address
  70         utxo.ControlProgramIndex = controlProg.KeyIndex
  71         txInput, sigInst, err := account.UtxoToInputs(testAccount.Signer, utxo, nil)
  72         if err != nil {
  73                 t.Fatal(err)
  74         }
  75
  76         b := txbuilder.NewBuilder(time.Now())
  77         b.AddInput(txInput, sigInst)
  78         out := legacy.NewTxOutput(*consensus.BTMAssetID, 100, []byte{byte(vm.OP_FAIL)}, nil)
  79         b.AddOutput(out)
  80         tpl, tx, err := b.Build()
  81         if err != nil {
  82                 t.Fatal(err)
  83         }
  84
  85         err = txbuilder.Sign(nil, tpl, nil, "password", func(_ context.Context, xpub chainkd.XPub, path [][]byte, data [32]byte, password string) ([]byte, error) {
  86                 sigBytes, err := hsm.XSign(xpub, path, data[:], password)
  87                 if err != nil {
  88                         return nil, nil
  89                 }
  90                 return sigBytes, err
  91         })
  92         if err != nil {
  93                 t.Fatal(err)
  94         }
  95
  96         bcBlock := &bc.Block{
  97                 BlockHeader: &bc.BlockHeader{Height: 1},
  98         }
  99         if _, err = validation.ValidateTx(legacy.MapTx(tx), bcBlock); err != nil {
 100                 t.Fatal(err)
 101         }
 102 }
 103
 104 func mockChain(testDB dbm.DB) (*protocol.Chain, error) {
 105         store := txdb.NewStore(testDB)
 106         txPool := protocol.NewTxPool()
 107         chain, err := protocol.NewChain(bc.Hash{}, store, txPool)
 108         if err != nil {
 109                 return nil, err
 110         }
 111         return chain, nil
 112 }