test/integration/standard_transaction_test.go

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