versoin1.1.9 (#594)

[bytom/vapor.git] / protocol / bc / types / map.go

diff --git a/protocol/bc/types/map.go b/protocol/bc/types/map.go
index 1568119..65533e2 100644 (file)
--- a/protocol/bc/types/map.go
+++ b/protocol/bc/types/map.go
@@ -2,11 +2,12 @@ package types
 
 import (
        log "github.com/sirupsen/logrus"
+       "golang.org/x/crypto/sha3"
 
-       "github.com/vapor/consensus"
-       "github.com/vapor/protocol/bc"
-       "github.com/vapor/protocol/vm"
-       "github.com/vapor/protocol/vm/vmutil"
+       "github.com/bytom/vapor/consensus"
+       "github.com/bytom/vapor/protocol/bc"
+       "github.com/bytom/vapor/protocol/vm"
+       "github.com/bytom/vapor/protocol/vm/vmutil"
 )
 
 // MapTx converts a types TxData object into its entries-based
@@ -39,6 +40,13 @@ func MapTx(oldTx *TxData) *bc.Tx {
                                tx.GasInputIDs = append(tx.GasInputIDs, id)
                        }
 
+               case *bc.VetoInput:
+                       ord = e.Ordinal
+                       spentOutputIDs[*e.SpentOutputId] = true
+                       if *e.WitnessDestination.Value.AssetId == *consensus.BTMAssetID {
+                               tx.GasInputIDs = append(tx.GasInputIDs, id)
+                       }
+
                case *bc.Coinbase:
                        ord = 0
                        tx.GasInputIDs = append(tx.GasInputIDs, id)
@@ -47,10 +55,9 @@ func MapTx(oldTx *TxData) *bc.Tx {
                        continue
                }
 
-               if ord >= uint64(len(oldTx.Inputs)) {
-                       continue
+               if ord < uint64(len(oldTx.Inputs)) {
+                       tx.InputIDs[ord] = id
                }
-               tx.InputIDs[ord] = id
        }
 
        for id := range spentOutputIDs {
@@ -71,9 +78,10 @@ func mapTx(tx *TxData) (headerID bc.Hash, hdr *bc.TxHeader, entryMap map[bc.Hash
        }
 
        var (
-               spends   []*bc.Spend
-               crossIns []*bc.CrossChainInput
-               coinbase *bc.Coinbase
+               spends     []*bc.Spend
+               vetoInputs []*bc.VetoInput
+               crossIns   []*bc.CrossChainInput
+               coinbase   *bc.Coinbase
        )
 
        muxSources := make([]*bc.ValueSource, len(tx.Inputs))
@@ -103,15 +111,19 @@ func mapTx(tx *TxData) (headerID bc.Hash, hdr *bc.TxHeader, entryMap map[bc.Hash
                case *CoinbaseInput:
                        coinbase = bc.NewCoinbase(inp.Arbitrary)
                        coinbaseID := addEntry(coinbase)
-
-                       out := tx.Outputs[0]
-                       value := out.AssetAmount()
+                       totalAmount := uint64(0)
+                       for _, out := range tx.Outputs {
+                               totalAmount += out.AssetAmount().Amount
+                       }
                        muxSources[i] = &bc.ValueSource{
-                               Ref:   &coinbaseID,
-                               Value: &value,
+                               Ref: &coinbaseID,
+                               Value: &bc.AssetAmount{
+                                       AssetId: consensus.BTMAssetID,
+                                       Amount:  totalAmount,
+                               },
                        }
 
-               case *UnvoteInput:
+               case *VetoInput:
                        prog := &bc.Program{VmVersion: inp.VMVersion, Code: inp.ControlProgram}
                        src := &bc.ValueSource{
                                Ref:      &inp.SourceID,
@@ -120,28 +132,38 @@ func mapTx(tx *TxData) (headerID bc.Hash, hdr *bc.TxHeader, entryMap map[bc.Hash
                        }
                        prevout := bc.NewVoteOutput(src, prog, 0, inp.Vote) // ordinal doesn't matter for prevouts, only for result outputs
                        prevoutID := addEntry(prevout)
-                       // create entry for spend
-                       spend := bc.NewSpend(&prevoutID, uint64(i))
-                       spend.WitnessArguments = inp.Arguments
-                       spendID := addEntry(spend)
+                       // create entry for VetoInput
+                       vetoInput := bc.NewVetoInput(&prevoutID, uint64(i))
+                       vetoInput.WitnessArguments = inp.Arguments
+                       vetoVoteID := addEntry(vetoInput)
                        // setup mux
                        muxSources[i] = &bc.ValueSource{
-                               Ref:   &spendID,
+                               Ref:   &vetoVoteID,
                                Value: &inp.AssetAmount,
                        }
-                       spends = append(spends, spend)
+                       vetoInputs = append(vetoInputs, vetoInput)
 
                case *CrossChainInput:
-                       // TODO: fed peg script
                        prog := &bc.Program{VmVersion: inp.VMVersion, Code: inp.ControlProgram}
                        src := &bc.ValueSource{
                                Ref:      &inp.SourceID,
                                Value:    &inp.AssetAmount,
                                Position: inp.SourcePosition,
                        }
+
                        prevout := bc.NewIntraChainOutput(src, prog, 0) // ordinal doesn't matter
-                       outputID := bc.EntryID(prevout)
-                       crossIn := bc.NewCrossChainInput(&outputID, &inp.AssetAmount, prog, uint64(i))
+                       mainchainOutputID := addEntry(prevout)
+
+                       assetDefHash := bc.NewHash(sha3.Sum256(inp.AssetDefinition))
+                       assetDef := &bc.AssetDefinition{
+                               Data: &assetDefHash,
+                               IssuanceProgram: &bc.Program{
+                                       VmVersion: inp.IssuanceVMVersion,
+                                       Code:      inp.IssuanceProgram,
+                               },
+                       }
+
+                       crossIn := bc.NewCrossChainInput(&mainchainOutputID, prog, uint64(i), assetDef, inp.AssetDefinition)
                        crossIn.WitnessArguments = inp.Arguments
                        crossInID := addEntry(crossIn)
                        muxSources[i] = &bc.ValueSource{
@@ -157,17 +179,18 @@ func mapTx(tx *TxData) (headerID bc.Hash, hdr *bc.TxHeader, entryMap map[bc.Hash
 
        // connect the inputs to the mux
        for _, spend := range spends {
-               switch spentOutput := entryMap[*spend.SpentOutputId].(type) {
-               case *bc.IntraChainOutput:
-                       spend.SetDestination(&muxID, spentOutput.Source.Value, spend.Ordinal)
+               spentOutput := entryMap[*spend.SpentOutputId].(*bc.IntraChainOutput)
+               spend.SetDestination(&muxID, spentOutput.Source.Value, spend.Ordinal)
+       }
 
-               case *bc.VoteOutput:
-                       spend.SetDestination(&muxID, spentOutput.Source.Value, spend.Ordinal)
-               }
+       for _, vetoInput := range vetoInputs {
+               voteOutput := entryMap[*vetoInput.SpentOutputId].(*bc.VoteOutput)
+               vetoInput.SetDestination(&muxID, voteOutput.Source.Value, vetoInput.Ordinal)
        }
 
        for _, crossIn := range crossIns {
-               crossIn.SetDestination(&muxID, crossIn.Value, crossIn.Ordinal)
+               mainchainOutput := entryMap[*crossIn.MainchainOutputId].(*bc.IntraChainOutput)
+               crossIn.SetDestination(&muxID, mainchainOutput.Source.Value, crossIn.Ordinal)
        }
 
        if coinbase != nil {
@@ -205,7 +228,7 @@ func mapTx(tx *TxData) (headerID bc.Hash, hdr *bc.TxHeader, entryMap map[bc.Hash
 
                case out.OutputType() == VoteOutputType:
                        // non-retirement vote tx
-                       voteOut, _ := out.TypedOutput.(*VoteTxOutput)
+                       voteOut, _ := out.TypedOutput.(*VoteOutput)
                        prog := &bc.Program{out.VMVersion(), out.ControlProgram()}
                        o := bc.NewVoteOutput(src, prog, uint64(i), voteOut.Vote)
                        resultID = addEntry(o)