application/mov/common/type.go

   1 package common
   2
   3 import (
   4         "fmt"
   5
   6         "github.com/vapor/consensus/segwit"
   7         "github.com/vapor/errors"
   8         "github.com/vapor/protocol/bc"
   9         "github.com/vapor/protocol/bc/types"
  10 )
  11
  12 type MovUtxo struct {
  13         SourceID       *bc.Hash
  14         SourcePos      uint64
  15         Amount         uint64
  16         ControlProgram []byte
  17 }
  18
  19 type Order struct {
  20         FromAssetID *bc.AssetID
  21         ToAssetID   *bc.AssetID
  22         Utxo        *MovUtxo
  23         Rate        float64
  24 }
  25
  26 type OrderSlice []*Order
  27
  28 func (o OrderSlice) Len() int {
  29         return len(o)
  30 }
  31 func (o OrderSlice) Swap(i, j int) {
  32         o[i], o[j] = o[j], o[i]
  33 }
  34 func (o OrderSlice) Less(i, j int) bool {
  35         return o[i].Rate < o[j].Rate
  36 }
  37
  38 func NewOrderFromOutput(tx *types.Tx, outputIndex int) (*Order, error) {
  39         outputID := tx.OutputID(outputIndex)
  40         output, err := tx.IntraChainOutput(*outputID)
  41         if err != nil {
  42                 return nil, err
  43         }
  44
  45         contractArgs, err := segwit.DecodeP2WMCProgram(output.ControlProgram.Code)
  46         if err != nil {
  47                 return nil, err
  48         }
  49
  50         assetAmount := output.Source.Value
  51         return &Order{
  52                 FromAssetID: assetAmount.AssetId,
  53                 ToAssetID:   &contractArgs.RequestedAsset,
  54                 Rate:        float64(contractArgs.RatioNumerator) / float64(contractArgs.RatioDenominator),
  55                 Utxo: &MovUtxo{
  56                         SourceID:       output.Source.Ref,
  57                         Amount:         assetAmount.Amount,
  58                         SourcePos:      uint64(outputIndex),
  59                         ControlProgram: output.ControlProgram.Code,
  60                 },
  61         }, nil
  62 }
  63
  64 func NewOrderFromInput(tx *types.Tx, inputIndex int) (*Order, error) {
  65         input, ok := tx.Inputs[inputIndex].TypedInput.(*types.SpendInput)
  66         if !ok {
  67                 return nil, errors.New("input is not type of spend input")
  68         }
  69
  70         contractArgs, err := segwit.DecodeP2WMCProgram(input.ControlProgram)
  71         if err != nil {
  72                 return nil, err
  73         }
  74
  75         return &Order{
  76                 FromAssetID: input.AssetId,
  77                 ToAssetID:   &contractArgs.RequestedAsset,
  78                 Rate:        float64(contractArgs.RatioNumerator) / float64(contractArgs.RatioDenominator),
  79                 Utxo: &MovUtxo{
  80                         SourceID:       &input.SourceID,
  81                         Amount:         input.Amount,
  82                         SourcePos:      input.SourcePosition,
  83                         ControlProgram: input.ControlProgram,
  84                 },
  85         }, nil
  86 }
  87
  88 func (o *Order) GetTradePair() *TradePair {
  89         return &TradePair{FromAssetID: o.FromAssetID, ToAssetID: o.ToAssetID}
  90 }
  91
  92 func (o *Order) Key() string {
  93         return fmt.Sprintf("%s:%d", o.Utxo.SourceID, o.Utxo.SourcePos)
  94 }
  95
  96 type TradePair struct {
  97         FromAssetID *bc.AssetID
  98         ToAssetID   *bc.AssetID
  99         Count       int
 100 }
 101
 102 func (t *TradePair) Reverse() *TradePair {
 103         return &TradePair{
 104                 FromAssetID: t.ToAssetID,
 105                 ToAssetID:   t.FromAssetID,
 106         }
 107 }
 108
 109 func (t *TradePair) Key() string {
 110         return fmt.Sprintf("%s:%s", t.FromAssetID, t.ToAssetID)
 111 }
 112
 113 type MovDatabaseState struct {
 114         Height uint64
 115         Hash   *bc.Hash
 116 }