+++ /dev/null
-package txbuilder
-
-import (
- "context"
- "encoding/hex"
- "encoding/json"
- "math"
- "testing"
- "time"
-
- "github.com/davecgh/go-spew/spew"
- "golang.org/x/crypto/sha3"
-
- "github.com/vapor/common"
- "github.com/vapor/consensus"
- "github.com/vapor/crypto"
- "github.com/vapor/crypto/ed25519"
- "github.com/vapor/crypto/ed25519/chainkd"
- chainjson "github.com/vapor/encoding/json"
- "github.com/vapor/errors"
- "github.com/vapor/protocol/bc"
- "github.com/vapor/protocol/bc/types"
- "github.com/vapor/protocol/vm"
- "github.com/vapor/protocol/vm/vmutil"
- "github.com/vapor/testutil"
-)
-
-type testAction bc.AssetAmount
-
-func (t testAction) Build(ctx context.Context, b *TemplateBuilder) error {
- in := types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), *t.AssetId, t.Amount, 0, nil)
- tplIn := &SigningInstruction{}
-
- err := b.AddInput(in, tplIn)
- if err != nil {
- return err
- }
- return b.AddOutput(types.NewTxOutput(*t.AssetId, t.Amount, []byte("change")))
-}
-
-func (t testAction) ActionType() string {
- return "test-action"
-}
-
-func newControlProgramAction(assetAmt bc.AssetAmount, script []byte) *controlProgramAction {
- return &controlProgramAction{
- AssetAmount: assetAmt,
- Program: script,
- }
-}
-
-func TestBuild(t *testing.T) {
- ctx := context.Background()
-
- assetID1 := bc.NewAssetID([32]byte{1})
- assetID2 := bc.NewAssetID([32]byte{2})
-
- actions := []Action{
- newControlProgramAction(bc.AssetAmount{AssetId: &assetID2, Amount: 6}, []byte("dest")),
- testAction(bc.AssetAmount{AssetId: &assetID1, Amount: 5}),
- }
- expiryTime := time.Now().Add(time.Minute)
- got, err := Build(ctx, nil, actions, expiryTime, 0)
- if err != nil {
- testutil.FatalErr(t, err)
- }
-
- want := &Template{
- Transaction: types.NewTx(types.TxData{
- Version: 1,
- Inputs: []*types.TxInput{
- types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), assetID1, 5, 0, nil),
- },
- Outputs: []*types.TxOutput{
- types.NewTxOutput(assetID2, 6, []byte("dest")),
- types.NewTxOutput(assetID1, 5, []byte("change")),
- },
- }),
- SigningInstructions: []*SigningInstruction{{
- WitnessComponents: []witnessComponent{},
- }},
- }
-
- if !testutil.DeepEqual(got.Transaction.TxData, want.Transaction.TxData) {
- t.Errorf("got tx:\n%s\nwant tx:\n%s", spew.Sdump(got.Transaction.TxData), spew.Sdump(want.Transaction.TxData))
- }
-
- if !testutil.DeepEqual(got.SigningInstructions, want.SigningInstructions) {
- t.Errorf("got signing instructions:\n\t%#v\nwant signing instructions:\n\t%#v", got.SigningInstructions, want.SigningInstructions)
- }
-}
-
-func TestSignatureWitnessMaterialize(t *testing.T) {
- privkey1, pubkey1, err := chainkd.NewXKeys(nil)
- if err != nil {
- t.Fatal(err)
- }
- privkey2, pubkey2, err := chainkd.NewXKeys(nil)
- if err != nil {
- t.Fatal(err)
- }
- privkey3, pubkey3, err := chainkd.NewXKeys(nil)
- if err != nil {
- t.Fatal(err)
- }
- issuanceProg, _ := vmutil.P2SPMultiSigProgram([]ed25519.PublicKey{pubkey1.PublicKey(), pubkey2.PublicKey(), pubkey3.PublicKey()}, 2)
- assetID := bc.ComputeAssetID(issuanceProg, 1, &bc.EmptyStringHash)
- outscript := mustDecodeHex("76a914c5d128911c28776f56baaac550963f7b88501dc388c0")
- unsigned := types.NewTx(types.TxData{
- Version: 1,
- Inputs: []*types.TxInput{
- types.NewIssuanceInput([]byte{1}, 100, issuanceProg, nil, nil),
- },
- Outputs: []*types.TxOutput{
- types.NewTxOutput(assetID, 100, outscript),
- },
- })
-
- tpl := &Template{
- Transaction: unsigned,
- }
- h := tpl.Hash(0)
- builder := vmutil.NewBuilder()
- builder.AddData(h.Bytes())
- builder.AddOp(vm.OP_TXSIGHASH).AddOp(vm.OP_EQUAL)
- prog, _ := builder.Build()
- msg := sha3.Sum256(prog)
- sig1 := privkey1.Sign(msg[:])
- sig2 := privkey2.Sign(msg[:])
- sig3 := privkey3.Sign(msg[:])
- want := [][]byte{
- vm.Int64Bytes(0),
- sig1,
- sig2,
- prog,
- }
-
- // Test with more signatures than required, in correct order
- tpl.SigningInstructions = []*SigningInstruction{{
- WitnessComponents: []witnessComponent{
- &SignatureWitness{
- Quorum: 2,
- Keys: []keyID{
- {
- XPub: pubkey1,
- DerivationPath: []chainjson.HexBytes{{0, 0, 0, 0}},
- },
- {
- XPub: pubkey2,
- DerivationPath: []chainjson.HexBytes{{0, 0, 0, 0}},
- },
- {
- XPub: pubkey3,
- DerivationPath: []chainjson.HexBytes{{0, 0, 0, 0}},
- },
- },
- Program: prog,
- Sigs: []chainjson.HexBytes{sig1, sig2, sig3},
- },
- },
- }}
- err = materializeWitnesses(tpl)
- if err != nil {
- testutil.FatalErr(t, err)
- }
- got := tpl.Transaction.Inputs[0].Arguments()
- if !testutil.DeepEqual(got, want) {
- t.Errorf("got input witness %v, want input witness %v", got, want)
- }
-
- // Test with exact amount of signatures required, in correct order
- component := tpl.SigningInstructions[0].WitnessComponents[0].(*SignatureWitness)
- component.Sigs = []chainjson.HexBytes{sig1, sig2}
- err = materializeWitnesses(tpl)
- if err != nil {
- testutil.FatalErr(t, err)
- }
- got = tpl.Transaction.Inputs[0].Arguments()
- if !testutil.DeepEqual(got, want) {
- t.Errorf("got input witness %v, want input witness %v", got, want)
- }
-}
-
-func mustDecodeHex(str string) []byte {
- data, err := hex.DecodeString(str)
- if err != nil {
- panic(err)
- }
- return data
-}
-
-func TestCheckBlankCheck(t *testing.T) {
- cases := []struct {
- tx *types.TxData
- want error
- }{{
- tx: &types.TxData{
- Inputs: []*types.TxInput{types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, 5, 0, nil)},
- },
- want: ErrBlankCheck,
- }, {
- tx: &types.TxData{
- Inputs: []*types.TxInput{types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, 5, 0, nil)},
- Outputs: []*types.TxOutput{types.NewTxOutput(bc.AssetID{}, 3, nil)},
- },
- want: ErrBlankCheck,
- }, {
- tx: &types.TxData{
- Inputs: []*types.TxInput{
- types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, 5, 0, nil),
- types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.NewAssetID([32]byte{1}), 5, 0, nil),
- },
- Outputs: []*types.TxOutput{types.NewTxOutput(bc.AssetID{}, 5, nil)},
- },
- want: ErrBlankCheck,
- }, {
- tx: &types.TxData{
- Inputs: []*types.TxInput{types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, 5, 0, nil)},
- Outputs: []*types.TxOutput{
- types.NewTxOutput(bc.AssetID{}, math.MaxInt64, nil),
- types.NewTxOutput(bc.AssetID{}, 7, nil),
- },
- },
- want: ErrBadAmount,
- }, {
- tx: &types.TxData{
- Inputs: []*types.TxInput{
- types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, 5, 0, nil),
- types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, math.MaxInt64, 0, nil),
- },
- },
- want: ErrBadAmount,
- }, {
- tx: &types.TxData{
- Inputs: []*types.TxInput{types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, 5, 0, nil)},
- Outputs: []*types.TxOutput{types.NewTxOutput(bc.AssetID{}, 5, nil)},
- },
- want: nil,
- }, {
- tx: &types.TxData{
- Outputs: []*types.TxOutput{types.NewTxOutput(bc.AssetID{}, 5, nil)},
- },
- want: nil,
- }, {
- tx: &types.TxData{
- Inputs: []*types.TxInput{types.NewSpendInput(nil, bc.NewHash([32]byte{0xff}), bc.AssetID{}, 5, 0, nil)},
- Outputs: []*types.TxOutput{types.NewTxOutput(bc.NewAssetID([32]byte{1}), 5, nil)},
- },
- want: nil,
- }}
-
- for _, c := range cases {
- got := checkBlankCheck(c.tx)
- if errors.Root(got) != c.want {
- t.Errorf("checkUnsafe(%+v) err = %v want %v", c.tx, errors.Root(got), c.want)
- }
- }
-}
-
-func TestCreateTxByUtxo(t *testing.T) {
- xprv, xpub, err := chainkd.NewXKeys(nil)
- if err != nil {
- t.Fatal(err)
- }
-
- pub := xpub.PublicKey()
- pubHash := crypto.Ripemd160(pub)
- program, err := vmutil.P2WPKHProgram([]byte(pubHash))
- if err != nil {
- t.Fatal(err)
- }
-
- address, err := common.NewAddressWitnessPubKeyHash(pubHash, &consensus.ActiveNetParams)
- if err != nil {
- t.Fatal(err)
- }
-
- muxID := testutil.MustDecodeHash("1e673900965623ec3305cead5a78dfb68a34599f8bc078460f3f202256c3dfa6")
- utxo := struct {
- SourceID bc.Hash
- AssetID bc.AssetID
- Amount uint64
- SourcePos uint64
- ControlProgram []byte
- Address string
- }{
- SourceID: muxID,
- AssetID: *consensus.BTMAssetID,
- Amount: 20000000000,
- SourcePos: 1,
- ControlProgram: program,
- Address: address.EncodeAddress(),
- }
-
- recvProg := mustDecodeHex("00145056532ecd3621c9ce8adde5505c058610b287cf")
- tx := types.NewTx(types.TxData{
- Version: 1,
- Inputs: []*types.TxInput{
- types.NewSpendInput(nil, utxo.SourceID, utxo.AssetID, utxo.Amount, utxo.SourcePos, utxo.ControlProgram),
- },
- Outputs: []*types.TxOutput{
- types.NewTxOutput(*consensus.BTMAssetID, 10000000000, recvProg),
- },
- })
-
- tpl := &Template{
- Transaction: tx,
- AllowAdditional: false,
- }
-
- h := tpl.Hash(0).Byte32()
- sig := xprv.Sign(h[:])
- data := []byte(pub)
-
- // Test with more signatures than required, in correct order
- tpl.SigningInstructions = []*SigningInstruction{{
- WitnessComponents: []witnessComponent{
- &RawTxSigWitness{
- Quorum: 1,
- Sigs: []chainjson.HexBytes{sig},
- },
- DataWitness(data),
- },
- }}
-
- if err = materializeWitnesses(tpl); err != nil {
- t.Fatal(err)
- }
-
- if !testutil.DeepEqual(tx, tpl.Transaction) {
- t.Errorf("tx:%v result is equal to want:%v", tx, tpl.Transaction)
- }
-}
-
-func TestAddContractArgs(t *testing.T) {
- hexXpub, err := hex.DecodeString("ba76bb52574b3f40315f2c01f1818a9072ced56e9d4b68acbef56a4d0077d08e5e34837963e4cdc54eb251aa34aad01e6ae48b140f6a2743fbb0a0abd9cf8aac")
- if err != nil {
- t.Fatal(err)
- }
-
- var xpub chainkd.XPub
- copy(xpub[:], hexXpub)
-
- rawTxSig := RawTxSigArgument{RootXPub: xpub, Path: []chainjson.HexBytes{{1, 1, 0, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0, 0, 0}}}
- rawTxSigMsg, err := json.Marshal(rawTxSig)
- if err != nil {
- t.Fatal(err)
- }
-
- value, err := hex.DecodeString("7468697320697320612074657374")
- if err != nil {
- t.Fatal(err)
- }
- data := DataArgument{value}
- dataMsg, err := json.Marshal(data)
- if err != nil {
- t.Fatal(err)
- }
-
- strMsg, err := json.Marshal(StrArgument{"this is a test string"})
- if err != nil {
- t.Fatal(err)
- }
-
- integerMsg, err := json.Marshal(IntegerArgument{100})
- if err != nil {
- t.Fatal(err)
- }
-
- boolMsg, err := json.Marshal(BoolArgument{true})
- if err != nil {
- t.Fatal(err)
- }
-
- cases := []struct {
- arguments []ContractArgument
- wantResult error
- }{
- {
- arguments: []ContractArgument{
- {
- Type: "raw_tx_signature",
- RawData: rawTxSigMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "data",
- RawData: dataMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "string",
- RawData: strMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "integer",
- RawData: integerMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "boolean",
- RawData: boolMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "raw_tx_signature",
- RawData: rawTxSigMsg,
- },
- {
- Type: "data",
- RawData: dataMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "data",
- RawData: dataMsg,
- },
- {
- Type: "raw_tx_signature",
- RawData: rawTxSigMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "raw_tx_signature",
- RawData: rawTxSigMsg,
- },
- {
- Type: "data",
- RawData: dataMsg,
- },
- {
- Type: "string",
- RawData: strMsg,
- },
- {
- Type: "integer",
- RawData: integerMsg,
- },
- {
- Type: "boolean",
- RawData: boolMsg,
- },
- },
- wantResult: nil,
- },
- {
- arguments: []ContractArgument{
- {
- Type: "data",
- RawData: dataMsg,
- },
- {
- Type: "err_data",
- RawData: rawTxSigMsg,
- },
- },
- wantResult: ErrBadContractArgType,
- },
- }
-
- sigInst := &SigningInstruction{}
- for _, c := range cases {
- err := AddContractArgs(sigInst, c.arguments)
- if err != c.wantResult {
- t.Fatalf("got result=%v, want result=%v", err, c.wantResult)
- }
- }
-}
OSDN Git Service
