package vm import ( "math/big" "github.com/CityOfZion/neo-go/pkg/vm/stack" ) // Stack Manipulation Opcodes // PushNBytes will Read N Bytes from the script and push it onto the stack func PushNBytes(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { val, err := ctx.ReadBytes(int(op)) if err != nil { return FAULT, err } ba := stack.NewByteArray(val) ctx.Estack.Push(ba) return NONE, nil } // ROLL pops an integer n off of the stack and // moves the n-item starting from // the top of the stack onto the top stack item. // Returns an error if the top stack item is not an // integer or n-item does not exist. func ROLL(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { n, err := ctx.Estack.PopInt() if err != nil { return FAULT, err } nItem, err := ctx.Estack.Remove(uint16(n.Value().Int64())) if err != nil { return FAULT, err } ctx.Estack.Push(nItem) return NONE, nil } // ROT moves the third top stack item // onto the top stack item. // Returns an error if the third top stack item // does not exist. func ROT(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Estack.Remove(2) if err != nil { return FAULT, err } ctx.Estack.Push(item) return NONE, nil } // SWAP swaps the second top stack item with // the top stack item. // Returns an error if the second top stack item // does not exist. func SWAP(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Estack.Remove(1) if err != nil { return FAULT, err } ctx.Estack.Push(item) return NONE, nil } // TUCK copies the top stack item and // inserts it before the second top stack item. // Returns an error if the stack is empty or // len(stack) is less or equal 2. func TUCK(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Estack.Peek(0) if err != nil { return FAULT, err } ras, err := ctx.Estack.Insert(2, item) if err != nil { return FAULT, err } ctx.Estack = *ras return NONE, nil } // DUP duplicates the top stack item. // Returns an error if stack is empty. func DUP(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Estack.Peek(0) if err != nil { return FAULT, err } ctx.Estack.Push(item) return NONE, nil } // XSWAP pops an integer n off of the stack and // swaps the n-item from the stack starting from // the top of the stack with the top stack item. func XSWAP(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { n, err := ctx.Estack.PopInt() if err != nil { return FAULT, err } nItem, err := ctx.Estack.Peek(uint16(n.Value().Int64())) if err != nil { return FAULT, err } item, err := ctx.Estack.Peek(0) if err != nil { return FAULT, err } if err := ctx.Estack.Set(uint16(n.Value().Int64()), item); err != nil { return FAULT, err } if err := ctx.Estack.Set(0, nItem); err != nil { return FAULT, err } return NONE, nil } // DUPFROMALTSTACK duplicates the item on top of alternative stack and // puts it on top of evaluation stack. // Returns an error if the alt stack is empty. func DUPFROMALTSTACK(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Astack.Peek(0) if err != nil { return FAULT, err } ctx.Estack.Push(item) return NONE, nil } // NIP removes the second top stack item. // Returns error if the stack item contains // only one element. func NIP(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { _, err := ctx.Estack.Remove(1) if err != nil { return FAULT, err } return NONE, nil } // OVER copies the second-to-top stack item onto the top. // Returns an error if the stack item contains // only one element. func OVER(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Estack.Peek(1) if err != nil { return FAULT, err } ctx.Estack.Push(item) return NONE, nil } // XTUCK pops an integer n off of the stack and // inserts the top stack item to the position len(stack)-n in the evaluation stack. func XTUCK(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { n, err := ctx.Estack.PopInt() if err != nil || n.Value().Int64() < 0 { return FAULT, err } item, err := ctx.Estack.Peek(0) if err != nil { return FAULT, err } ras, err := ctx.Estack.Insert(uint16(n.Value().Int64()), item) if err != nil { return FAULT, err } ctx.Estack = *ras return NONE, nil } // TOALTSTACK pops an item off of the evaluation stack and // pushes it on top of the alternative stack. // Returns an error if the alternative stack is empty. func TOALTSTACK(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Estack.Pop() if err != nil { return FAULT, err } ctx.Astack.Push(item) return NONE, nil } // DEPTH puts the number of stack items onto the stack. func DEPTH(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { l := ctx.Estack.Len() length, err := stack.NewInt(big.NewInt(int64(l))) if err != nil { return FAULT, err } ctx.Estack.Push(length) return NONE, nil } // FROMALTSTACK pops an item off of the alternative stack and // pushes it on top of the evaluation stack. // Returns an error if the evaluation stack is empty. func FROMALTSTACK(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { item, err := ctx.Astack.Pop() if err != nil { return FAULT, err } ctx.Estack.Push(item) return NONE, nil } // PICK pops an integer n off of the stack and // copies the n-item starting from // the top of the stack onto the top stack item. // Returns an error if the top stack item is not an // integer or n-item does not exist. func PICK(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { n, err := ctx.Estack.PopInt() if err != nil { return FAULT, err } nItem, err := ctx.Estack.Peek(uint16(n.Value().Int64())) if err != nil { return FAULT, err } ctx.Estack.Push(nItem) return NONE, nil } // DROP removes the the top stack item. // Returns error if the operation Pop cannot // be performed. func DROP(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { _, err := ctx.Estack.Pop() if err != nil { return FAULT, err } return NONE, nil } // XDROP pops an integer n off of the stack and // removes the n-item from the stack starting from // the top of the stack. func XDROP(op stack.Instruction, ctx *stack.Context, istack *stack.Invocation, rstack *stack.RandomAccess) (Vmstate, error) { n, err := ctx.Estack.PopInt() if err != nil { return FAULT, err } ctx.Estack.Remove(uint16(n.Value().Uint64())) if err != nil { return FAULT, err } return NONE, nil }