summary |
shortlog |
log |
commit | commitdiff |
tree
raw |
patch |
inline | side by side (from parent 1:
6fe92f6)
Co-authored-by: paladz <colt@ColtdeMacBook-Pro.local>
OP_PUSHDATA2: {OP_PUSHDATA2, "PUSHDATA2", opPushdata},
OP_PUSHDATA4: {OP_PUSHDATA4, "PUSHDATA4", opPushdata},
OP_PUSHDATA2: {OP_PUSHDATA2, "PUSHDATA2", opPushdata},
OP_PUSHDATA4: {OP_PUSHDATA4, "PUSHDATA4", opPushdata},
- OP_1NEGATE: {OP_1NEGATE, "1NEGATE", op1Negate},
-
OP_NOP: {OP_NOP, "NOP", opNop},
// control flow
OP_NOP: {OP_NOP, "NOP", opNop},
// control flow
return vm.push(d, false)
}
return vm.push(d, false)
}
-func op1Negate(vm *virtualMachine) error {
- err := vm.applyCost(1)
- if err != nil {
- return err
- }
- return vm.pushInt64(-1, false)
-}
-
func opNop(vm *virtualMachine) error {
return vm.applyCost(1)
}
func opNop(vm *virtualMachine) error {
return vm.applyCost(1)
}
dataStack: [][]byte{},
},
wantErr: ErrRunLimitExceeded,
dataStack: [][]byte{},
},
wantErr: ErrRunLimitExceeded,
- }, {
- op: OP_1NEGATE,
- startVM: &virtualMachine{
- runLimit: 50000,
- dataStack: [][]byte{},
- },
- wantVM: &virtualMachine{
- runLimit: 49983,
- dataStack: [][]byte{Int64Bytes(-1)},
- },
- }, {
- op: OP_1NEGATE,
- startVM: &virtualMachine{
- runLimit: 1,
- dataStack: [][]byte{},
- },
- wantErr: ErrRunLimitExceeded,
}}
pushdataops := []Op{OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}
}}
pushdataops := []Op{OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4}
"testing"
"github.com/holiman/uint256"
"testing"
"github.com/holiman/uint256"
+
+ "github.com/bytom/bytom/testutil"
)
func TestBoolBytes(t *testing.T) {
)
func TestBoolBytes(t *testing.T) {
+
+func TestInt64BigIntConvert(t *testing.T) {
+ cases := []int64{0, 1, 2, 1024, 65536, 9223372036854775807}
+ for i, c := range cases {
+ x := Int64Bytes(c)
+ y := BigIntBytes(uint256.NewInt().SetUint64(uint64(c)))
+ if !testutil.DeepEqual(x, y) {
+ t.Errorf("case %d fail on compare %d bytes", i, c)
+ }
+ }
+}
runLimit: gasLimit,
context: context,
}
runLimit: gasLimit,
context: context,
}
- stateData := context.StateData
- for i, state := range stateData {
+
+ for i, state := range context.StateData {
if err = vm.pushAlt(state, false); err != nil {
return vm.runLimit, errors.Wrapf(err, "pushing initial statedata %d", i)
}
}
if err = vm.pushAlt(state, false); err != nil {
return vm.runLimit, errors.Wrapf(err, "pushing initial statedata %d", i)
}
}
- args := context.Arguments
- for i, arg := range args {
- err = vm.push(arg, false)
- if err != nil {
+ for i, arg := range context.Arguments {
+ if err = vm.push(arg, false); err != nil {
return vm.runLimit, errors.Wrapf(err, "pushing initial argument %d", i)
}
}
return vm.runLimit, errors.Wrapf(err, "pushing initial argument %d", i)
}
}
- return vm.runLimit, wrapErr(err, vm, args)
+ return vm.runLimit, wrapErr(err, vm, context.Arguments)
}
// falseResult returns true iff the stack is empty or the top
}
// falseResult returns true iff the stack is empty or the top
func (vm *virtualMachine) run() error {
for vm.pc = 0; vm.pc < uint32(len(vm.program)); { // handle vm.pc updates in step
func (vm *virtualMachine) run() error {
for vm.pc = 0; vm.pc < uint32(len(vm.program)); { // handle vm.pc updates in step
- err := vm.step()
- if err != nil {
+ if err := vm.step(); err != nil {
vm.deferredCost = 0
vm.data = inst.Data
vm.deferredCost = 0
vm.data = inst.Data
- err = ops[inst.Op].fn(vm)
- if err != nil {
+ if err = ops[inst.Op].fn(vm); err != nil {
- err = vm.applyCost(vm.deferredCost)
- if err != nil {
+
+ if err = vm.applyCost(vm.deferredCost); err != nil {
if TraceOut != nil {
for i := len(vm.dataStack) - 1; i >= 0; i-- {
fmt.Fprintf(TraceOut, " stack %d: %x\n", len(vm.dataStack)-1-i, vm.dataStack[i])
if TraceOut != nil {
for i := len(vm.dataStack) - 1; i >= 0; i-- {
fmt.Fprintf(TraceOut, " stack %d: %x\n", len(vm.dataStack)-1-i, vm.dataStack[i])
cost := 8 + int64(len(data))
if deferred {
vm.deferCost(cost)
cost := 8 + int64(len(data))
if deferred {
vm.deferCost(cost)
- } else {
- err := vm.applyCost(cost)
- if err != nil {
- return err
- }
+ } else if err := vm.applyCost(cost); err != nil {
+ return err
vm.dataStack = append(vm.dataStack, data)
return nil
}
vm.dataStack = append(vm.dataStack, data)
return nil
}
cost := 8 + int64(len(data))
if deferred {
vm.deferCost(cost)
cost := 8 + int64(len(data))
if deferred {
vm.deferCost(cost)
- } else {
- err := vm.applyCost(cost)
- if err != nil {
- return err
- }
+ } else if err := vm.applyCost(cost); err != nil {
+ return err
- vm.altStack = append(vm.altStack, data)
+ vm.altStack = append(vm.altStack, data)
if err != nil {
return 0, err
}
if err != nil {
return 0, err
}
- n, err := AsInt64(bytes)
- return n, err
+
+ return AsInt64(bytes)
}
func (vm *virtualMachine) popBigInt(deferred bool) (*uint256.Int, error) {
}
func (vm *virtualMachine) popBigInt(deferred bool) (*uint256.Int, error) {
if len(vm.dataStack) == 0 {
return nil, ErrDataStackUnderflow
}
if len(vm.dataStack) == 0 {
return nil, ErrDataStackUnderflow
}
return vm.dataStack[len(vm.dataStack)-1], nil
}
return vm.dataStack[len(vm.dataStack)-1], nil
}
vm.runLimit = 0
return ErrRunLimitExceeded
}
vm.runLimit = 0
return ErrRunLimitExceeded
}
vm.runLimit -= n
return nil
}
vm.runLimit -= n
return nil
}