test/integration/standard_transaction_test.go

   1 package integration
   2
   3 import (
   4         "encoding/json"
   5         "io/ioutil"
   6         "os"
   7         "testing"
   8
   9         "github.com/vapor/account"
  10         "github.com/vapor/blockchain/pseudohsm"
  11         "github.com/vapor/blockchain/signers"
  12         "github.com/vapor/crypto/ed25519/chainkd"
  13         "github.com/vapor/database"
  14         dbm "github.com/vapor/database/leveldb"
  15         "github.com/vapor/protocol/bc/types"
  16         "github.com/vapor/protocol/validation"
  17         "github.com/vapor/test"
  18 )
  19
  20 func TestP2PKH(t *testing.T) {
  21         dirPath, err := ioutil.TempDir(".", "TestP2PKH")
  22         if err != nil {
  23                 t.Fatal(err)
  24         }
  25         defer os.RemoveAll(dirPath)
  26
  27         testDB := dbm.NewDB("testdb", "leveldb", "temp")
  28         defer os.RemoveAll("temp")
  29
  30         chain, _, _, err := test.MockChain(testDB)
  31         if err != nil {
  32                 t.Fatal(err)
  33         }
  34
  35         accountStore := database.NewAccountStore(testDB)
  36         accountManager := account.NewManager(accountStore, chain)
  37         hsm, err := pseudohsm.New(dirPath)
  38         if err != nil {
  39                 t.Fatal(err)
  40         }
  41
  42         xpub, _, err := hsm.XCreate("TestP2PKH", "password", "en")
  43         if err != nil {
  44                 t.Fatal(err)
  45         }
  46
  47         testAccount, err := accountManager.Create([]chainkd.XPub{xpub.XPub}, 1, "testAccount", signers.BIP0044)
  48         if err != nil {
  49                 t.Fatal(err)
  50         }
  51
  52         controlProg, err := accountManager.CreateAddress(testAccount.ID, false)
  53         if err != nil {
  54                 t.Fatal(err)
  55         }
  56         utxo := test.MockUTXO(controlProg)
  57         tpl, tx, err := test.MockTx(utxo, testAccount)
  58         if err != nil {
  59                 t.Fatal(err)
  60         }
  61
  62         if _, err := test.MockSign(tpl, hsm, "password"); err != nil {
  63                 t.Fatal(err)
  64         }
  65
  66         tx.SerializedSize = 1
  67         if _, err = validation.ValidateTx(types.MapTx(tx), test.MockBlock()); err != nil {
  68                 t.Fatal(err)
  69         }
  70 }
  71
  72 func TestBip0032P2PKH(t *testing.T) {
  73         dirPath, err := ioutil.TempDir(".", "TestP2PKH")
  74         if err != nil {
  75                 t.Fatal(err)
  76         }
  77         defer os.RemoveAll(dirPath)
  78
  79         testDB := dbm.NewDB("testdb", "leveldb", "temp")
  80         defer os.RemoveAll("temp")
  81
  82         chain, _, _, err := test.MockChain(testDB)
  83         if err != nil {
  84                 t.Fatal(err)
  85         }
  86
  87         accountStore := database.NewAccountStore(testDB)
  88         accountManager := account.NewManager(accountStore, chain)
  89         hsm, err := pseudohsm.New(dirPath)
  90         if err != nil {
  91                 t.Fatal(err)
  92         }
  93
  94         xpub, _, err := hsm.XCreate("TestP2PKH", "password", "en")
  95         if err != nil {
  96                 t.Fatal(err)
  97         }
  98
  99         testAccount, err := accountManager.Create([]chainkd.XPub{xpub.XPub}, 1, "testAccount1", signers.BIP0044)
 100         if err != nil {
 101                 t.Fatal(err)
 102         }
 103
 104         signer, err := signers.Create("account", []chainkd.XPub{xpub.XPub}, 1, 2, signers.BIP0032)
 105         if err != nil {
 106                 t.Fatal(err)
 107         }
 108
 109         testAccount.Signer = signer
 110         rawAccount, err := json.Marshal(testAccount)
 111         if err != nil {
 112                 t.Fatal(err)
 113         }
 114
 115         testDB.Set(database.AccountIDKey(testAccount.ID), rawAccount)
 116         controlProg, err := accountManager.CreateAddress(testAccount.ID, false)
 117         if err != nil {
 118                 t.Fatal(err)
 119         }
 120
 121         utxo := test.MockUTXO(controlProg)
 122         tpl, tx, err := test.MockTx(utxo, testAccount)
 123         if err != nil {
 124                 t.Fatal(err)
 125         }
 126
 127         if _, err := test.MockSign(tpl, hsm, "password"); err != nil {
 128                 t.Fatal(err)
 129         }
 130
 131         tx.SerializedSize = 1
 132         if _, err = validation.ValidateTx(types.MapTx(tx), test.MockBlock()); err != nil {
 133                 t.Fatal(err)
 134         }
 135 }
 136
 137 func TestP2SH(t *testing.T) {
 138         dirPath, err := ioutil.TempDir(".", "TestP2SH")
 139         if err != nil {
 140                 t.Fatal(err)
 141         }
 142         defer os.RemoveAll(dirPath)
 143
 144         testDB := dbm.NewDB("testdb", "leveldb", "temp")
 145         defer os.RemoveAll("temp")
 146
 147         chain, _, _, err := test.MockChain(testDB)
 148         if err != nil {
 149                 t.Fatal(err)
 150         }
 151
 152         accountStore := database.NewAccountStore(testDB)
 153         accountManager := account.NewManager(accountStore, chain)
 154         hsm, err := pseudohsm.New(dirPath)
 155         if err != nil {
 156                 t.Fatal(err)
 157         }
 158
 159         xpub1, _, err := hsm.XCreate("TestP2SH1", "password", "en")
 160         if err != nil {
 161                 t.Fatal(err)
 162         }
 163
 164         xpub2, _, err := hsm.XCreate("TestP2SH2", "password", "en")
 165         if err != nil {
 166                 t.Fatal(err)
 167         }
 168
 169         testAccount, err := accountManager.Create([]chainkd.XPub{xpub1.XPub, xpub2.XPub}, 2, "testAccount", signers.BIP0044)
 170         if err != nil {
 171                 t.Fatal(err)
 172         }
 173
 174         controlProg, err := accountManager.CreateAddress(testAccount.ID, false)
 175         if err != nil {
 176                 t.Fatal(err)
 177         }
 178
 179         utxo := test.MockUTXO(controlProg)
 180         tpl, tx, err := test.MockTx(utxo, testAccount)
 181         if err != nil {
 182                 t.Fatal(err)
 183         }
 184
 185         // the number of sign transaction is equal to the count of xpub for account
 186         if _, err := test.MockSign(tpl, hsm, "password"); err != nil {
 187                 t.Fatal(err)
 188         }
 189         if _, err := test.MockSign(tpl, hsm, "password"); err != nil {
 190                 t.Fatal(err)
 191         }
 192
 193         tx.SerializedSize = 1
 194         if _, err = validation.ValidateTx(types.MapTx(tx), test.MockBlock()); err != nil {
 195                 t.Fatal(err)
 196         }
 197 }
 198
 199 func TestBip0032P2SH(t *testing.T) {
 200         dirPath, err := ioutil.TempDir(".", "TestP2SH")
 201         if err != nil {
 202                 t.Fatal(err)
 203         }
 204         defer os.RemoveAll(dirPath)
 205
 206         testDB := dbm.NewDB("testdb", "leveldb", "temp")
 207         defer os.RemoveAll("temp")
 208
 209         chain, _, _, err := test.MockChain(testDB)
 210         if err != nil {
 211                 t.Fatal(err)
 212         }
 213
 214         accountStore := database.NewAccountStore(testDB)
 215         accountManager := account.NewManager(accountStore, chain)
 216         hsm, err := pseudohsm.New(dirPath)
 217         if err != nil {
 218                 t.Fatal(err)
 219         }
 220
 221         xpub1, _, err := hsm.XCreate("TestP2SH1", "password", "en")
 222         if err != nil {
 223                 t.Fatal(err)
 224         }
 225
 226         xpub2, _, err := hsm.XCreate("TestP2SH2", "password", "en")
 227         if err != nil {
 228                 t.Fatal(err)
 229         }
 230
 231         testAccount, err := accountManager.Create([]chainkd.XPub{xpub1.XPub, xpub2.XPub}, 2, "testAccount", signers.BIP0044)
 232         if err != nil {
 233                 t.Fatal(err)
 234         }
 235         signer, err := signers.Create("account", []chainkd.XPub{xpub1.XPub, xpub2.XPub}, 2, 2, signers.BIP0032)
 236         if err != nil {
 237                 t.Fatal(err)
 238         }
 239
 240         testAccount.Signer = signer
 241         rawAccount, err := json.Marshal(testAccount)
 242         if err != nil {
 243                 t.Fatal(err)
 244         }
 245
 246         testDB.Set(database.AccountIDKey(testAccount.ID), rawAccount)
 247
 248         controlProg, err := accountManager.CreateAddress(testAccount.ID, false)
 249         if err != nil {
 250                 t.Fatal(err)
 251         }
 252
 253         utxo := test.MockUTXO(controlProg)
 254         tpl, tx, err := test.MockTx(utxo, testAccount)
 255         if err != nil {
 256                 t.Fatal(err)
 257         }
 258
 259         // the number of sign transaction is equal to the count of xpub for account
 260         if _, err := test.MockSign(tpl, hsm, "password"); err != nil {
 261                 t.Fatal(err)
 262         }
 263         if _, err := test.MockSign(tpl, hsm, "password"); err != nil {
 264                 t.Fatal(err)
 265         }
 266
 267         tx.SerializedSize = 1
 268         if _, err = validation.ValidateTx(types.MapTx(tx), test.MockBlock()); err != nil {
 269                 t.Fatal(err)
 270         }
 271 }
 272
 273 func TestMutilNodeSign(t *testing.T) {
 274         dirPath, err := ioutil.TempDir(".", "TestMutilNodeSign")
 275         if err != nil {
 276                 t.Fatal(err)
 277         }
 278         defer os.RemoveAll(dirPath)
 279
 280         testDB := dbm.NewDB("testdb", "leveldb", "temp")
 281         defer os.RemoveAll("temp")
 282
 283         chain, _, _, err := test.MockChain(testDB)
 284         if err != nil {
 285                 t.Fatal(err)
 286         }
 287
 288         accountStore := database.NewAccountStore(testDB)
 289         accountManager := account.NewManager(accountStore, chain)
 290         hsm, err := pseudohsm.New(dirPath)
 291         if err != nil {
 292                 t.Fatal(err)
 293         }
 294
 295         xpub1, _, err := hsm.XCreate("TestMutilNodeSign1", "password1", "en")
 296         if err != nil {
 297                 t.Fatal(err)
 298         }
 299
 300         xpub2, _, err := hsm.XCreate("TestMutilNodeSign2", "password2", "en")
 301         if err != nil {
 302                 t.Fatal(err)
 303         }
 304
 305         testAccount, err := accountManager.Create([]chainkd.XPub{xpub1.XPub, xpub2.XPub}, 2, "testAccount", signers.BIP0044)
 306         if err != nil {
 307                 t.Fatal(err)
 308         }
 309
 310         controlProg, err := accountManager.CreateAddress(testAccount.ID, false)
 311         if err != nil {
 312                 t.Fatal(err)
 313         }
 314
 315         utxo := test.MockUTXO(controlProg)
 316         tpl, tx, err := test.MockTx(utxo, testAccount)
 317         if err != nil {
 318                 t.Fatal(err)
 319         }
 320
 321         if finishSign, err := test.MockSign(tpl, hsm, "password"); err != nil {
 322                 t.Fatal(err)
 323         } else if finishSign == true {
 324                 t.Fatal("sign progress is finish, but either xpub1 nor xpub2 is signed")
 325         }
 326
 327         if finishSign, err := test.MockSign(tpl, hsm, "password1"); err != nil {
 328                 t.Fatal(err)
 329         } else if finishSign == true {
 330                 t.Fatal("sign progress is finish, but xpub2 is not signed")
 331         }
 332
 333         if finishSign, err := test.MockSign(tpl, hsm, "password2"); err != nil {
 334                 t.Fatal(err)
 335         } else if finishSign == false {
 336                 t.Fatal("sign progress is not finish,  but both xpub1 and xpub2 is signed")
 337         }
 338
 339         tx.SerializedSize = 1
 340         if _, err = validation.ValidateTx(types.MapTx(tx), test.MockBlock()); err != nil {
 341                 t.Fatal(err)
 342         }
 343 }
 344
 345 func TestBip0032MutilNodeSign(t *testing.T) {
 346         dirPath, err := ioutil.TempDir(".", "TestMutilNodeSign")
 347         if err != nil {
 348                 t.Fatal(err)
 349         }
 350         defer os.RemoveAll(dirPath)
 351
 352         testDB := dbm.NewDB("testdb", "leveldb", "temp")
 353         defer os.RemoveAll("temp")
 354
 355         chain, _, _, err := test.MockChain(testDB)
 356         if err != nil {
 357                 t.Fatal(err)
 358         }
 359
 360         accountStore := database.NewAccountStore(testDB)
 361         accountManager := account.NewManager(accountStore, chain)
 362         hsm, err := pseudohsm.New(dirPath)
 363         if err != nil {
 364                 t.Fatal(err)
 365         }
 366
 367         xpub1, _, err := hsm.XCreate("TestMutilNodeSign1", "password1", "en")
 368         if err != nil {
 369                 t.Fatal(err)
 370         }
 371
 372         xpub2, _, err := hsm.XCreate("TestMutilNodeSign2", "password2", "en")
 373         if err != nil {
 374                 t.Fatal(err)
 375         }
 376
 377         testAccount, err := accountManager.Create([]chainkd.XPub{xpub1.XPub, xpub2.XPub}, 2, "testAccount", signers.BIP0044)
 378         if err != nil {
 379                 t.Fatal(err)
 380         }
 381
 382         signer, err := signers.Create("account", []chainkd.XPub{xpub1.XPub, xpub2.XPub}, 2, 2, signers.BIP0032)
 383         if err != nil {
 384                 t.Fatal(err)
 385         }
 386
 387         testAccount.Signer = signer
 388         rawAccount, err := json.Marshal(testAccount)
 389         if err != nil {
 390                 t.Fatal(err)
 391         }
 392
 393         testDB.Set(database.AccountIDKey(testAccount.ID), rawAccount)
 394
 395         controlProg, err := accountManager.CreateAddress(testAccount.ID, false)
 396         if err != nil {
 397                 t.Fatal(err)
 398         }
 399
 400         utxo := test.MockUTXO(controlProg)
 401         tpl, tx, err := test.MockTx(utxo, testAccount)
 402         if err != nil {
 403                 t.Fatal(err)
 404         }
 405
 406         if finishSign, err := test.MockSign(tpl, hsm, "password"); err != nil {
 407                 t.Fatal(err)
 408         } else if finishSign == true {
 409                 t.Fatal("sign progress is finish, but either xpub1 nor xpub2 is signed")
 410         }
 411
 412         if finishSign, err := test.MockSign(tpl, hsm, "password1"); err != nil {
 413                 t.Fatal(err)
 414         } else if finishSign == true {
 415                 t.Fatal("sign progress is finish, but xpub2 is not signed")
 416         }
 417
 418         if finishSign, err := test.MockSign(tpl, hsm, "password2"); err != nil {
 419                 t.Fatal(err)
 420         } else if finishSign == false {
 421                 t.Fatal("sign progress is not finish,  but both xpub1 and xpub2 is signed")
 422         }
 423
 424         tx.SerializedSize = 1
 425         if _, err = validation.ValidateTx(types.MapTx(tx), test.MockBlock()); err != nil {
 426                 t.Fatal(err)
 427         }
 428 }