protocol/vm/introspection.go

   1 package vm
   2
   3 import "math"
   4
   5 func opCheckOutput(vm *virtualMachine) error {
   6         err := vm.applyCost(16)
   7         if err != nil {
   8                 return err
   9         }
  10
  11         code, err := vm.pop(true)
  12         if err != nil {
  13                 return err
  14         }
  15         vmVersion, err := vm.popInt64(true)
  16         if err != nil {
  17                 return err
  18         }
  19         if vmVersion < 0 {
  20                 return ErrBadValue
  21         }
  22         assetID, err := vm.pop(true)
  23         if err != nil {
  24                 return err
  25         }
  26         amount, err := vm.popInt64(true)
  27         if err != nil {
  28                 return err
  29         }
  30         if amount < 0 {
  31                 return ErrBadValue
  32         }
  33         data, err := vm.pop(true)
  34         if err != nil {
  35                 return err
  36         }
  37         index, err := vm.popInt64(true)
  38         if err != nil {
  39                 return err
  40         }
  41         if index < 0 {
  42                 return ErrBadValue
  43         }
  44
  45         if vm.context.CheckOutput == nil {
  46                 return ErrContext
  47         }
  48
  49         ok, err := vm.context.CheckOutput(uint64(index), data, uint64(amount), assetID, uint64(vmVersion), code, vm.expansionReserved)
  50         if err != nil {
  51                 return err
  52         }
  53         return vm.pushBool(ok, true)
  54 }
  55
  56 func opAsset(vm *virtualMachine) error {
  57         err := vm.applyCost(1)
  58         if err != nil {
  59                 return err
  60         }
  61
  62         if vm.context.AssetID == nil {
  63                 return ErrContext
  64         }
  65         return vm.push(*vm.context.AssetID, true)
  66 }
  67
  68 func opAmount(vm *virtualMachine) error {
  69         err := vm.applyCost(1)
  70         if err != nil {
  71                 return err
  72         }
  73
  74         if vm.context.Amount == nil {
  75                 return ErrContext
  76         }
  77         return vm.pushInt64(int64(*vm.context.Amount), true)
  78 }
  79
  80 func opProgram(vm *virtualMachine) error {
  81         err := vm.applyCost(1)
  82         if err != nil {
  83                 return err
  84         }
  85
  86         return vm.push(vm.context.Code, true)
  87 }
  88
  89 func opMinTime(vm *virtualMachine) error {
  90         err := vm.applyCost(1)
  91         if err != nil {
  92                 return err
  93         }
  94
  95         if vm.context.MinTimeMS == nil {
  96                 return ErrContext
  97         }
  98         return vm.pushInt64(int64(*vm.context.MinTimeMS), true)
  99 }
 100
 101 func opMaxTime(vm *virtualMachine) error {
 102         err := vm.applyCost(1)
 103         if err != nil {
 104                 return err
 105         }
 106
 107         if vm.context.MaxTimeMS == nil {
 108                 return ErrContext
 109         }
 110         maxTimeMS := *vm.context.MaxTimeMS
 111         if maxTimeMS == 0 || maxTimeMS > math.MaxInt64 {
 112                 maxTimeMS = uint64(math.MaxInt64)
 113         }
 114
 115         return vm.pushInt64(int64(maxTimeMS), true)
 116 }
 117
 118 func opEntryData(vm *virtualMachine) error {
 119         err := vm.applyCost(1)
 120         if err != nil {
 121                 return err
 122         }
 123
 124         if vm.context.EntryData == nil {
 125                 return ErrContext
 126         }
 127
 128         return vm.push(*vm.context.EntryData, true)
 129 }
 130
 131 func opTxData(vm *virtualMachine) error {
 132         err := vm.applyCost(1)
 133         if err != nil {
 134                 return err
 135         }
 136
 137         if vm.context.TxData == nil {
 138                 return ErrContext
 139         }
 140         return vm.push(*vm.context.TxData, true)
 141 }
 142
 143 func opIndex(vm *virtualMachine) error {
 144         err := vm.applyCost(1)
 145         if err != nil {
 146                 return err
 147         }
 148
 149         if vm.context.DestPos == nil {
 150                 return ErrContext
 151         }
 152         return vm.pushInt64(int64(*vm.context.DestPos), true)
 153 }
 154
 155 func opEntryID(vm *virtualMachine) error {
 156         err := vm.applyCost(1)
 157         if err != nil {
 158                 return err
 159         }
 160         return vm.push(vm.context.EntryID, true)
 161 }
 162
 163 func opOutputID(vm *virtualMachine) error {
 164         err := vm.applyCost(1)
 165         if err != nil {
 166                 return err
 167         }
 168
 169         if vm.context.SpentOutputID == nil {
 170                 return ErrContext
 171         }
 172         return vm.push(*vm.context.SpentOutputID, true)
 173 }
 174
 175 func opNonce(vm *virtualMachine) error {
 176         err := vm.applyCost(1)
 177         if err != nil {
 178                 return err
 179         }
 180
 181         if vm.context.AnchorID == nil {
 182                 return ErrContext
 183         }
 184         return vm.push(*vm.context.AnchorID, true)
 185 }
 186
 187 func opNextProgram(vm *virtualMachine) error {
 188         err := vm.applyCost(1)
 189         if err != nil {
 190                 return err
 191         }
 192
 193         if vm.context.NextConsensusProgram == nil {
 194                 return ErrContext
 195         }
 196         return vm.push(*vm.context.NextConsensusProgram, true)
 197 }
 198
 199 func opBlockTime(vm *virtualMachine) error {
 200         err := vm.applyCost(1)
 201         if err != nil {
 202                 return err
 203         }
 204
 205         if vm.context.BlockTimeMS == nil {
 206                 return ErrContext
 207         }
 208         return vm.pushInt64(int64(*vm.context.BlockTimeMS), true)
 209 }