gloads opcode

* Fix incorrect opcode details

* Refactor `gload` implementation into shared method

Author: jdtzmn

data/transactions/logic/README.md

@@ -170,6 +170,7 @@ Some of these have immediate data in the byte or bytes after the opcode.
 | `load i` | copy a value from scratch space to the stack |
 | `store i` | pop a value from the stack and store to scratch space |
 | `gload t i` | push Ith scratch space index of the Tth transaction in the current group |
+| `gloads i` | push Ith scratch space index of the Ath transaction in the current group |
 
 **Transaction Fields**
 

data/transactions/logic/TEAL_opcodes.md

@@ -521,6 +521,24 @@ for notes on transaction fields available, see `txn`. If top of stack is _i_, `g
 - push Ith value of the array field F from the Ath transaction in the current group
 - LogicSigVersion >= 3
 
+## gload t i
+
+- Opcode: 0x3a {uint8 transaction group index} {uint8 position in scratch space to load from}
+- Pops: _None_
+- Pushes: any
+- push Ith scratch space index of the Tth transaction in the current group
+- LogicSigVersion >= 4
+- Mode: Application
+
+## gloads i
+
+- Opcode: 0x3b {uint8 position in scratch space to load from}
+- Pops: *... stack*, uint64
+- Pushes: any
+- push Ith scratch space index of the Ath transaction in the current group
+- LogicSigVersion >= 4
+- Mode: Application
+
 ## bnz target
 
 - Opcode: 0x40 {int16 branch offset, big endian. (negative offsets are illegal before v4)}
@@ -881,11 +899,3 @@ The call stack is separate from the data stack. Only `callsub` and `retsub` mani
 - LogicSigVersion >= 4
 
 The call stack is separate from the data stack. Only `callsub` and `retsub` manipulate it.`
-
-## gload t i
-
-- Opcode: 0xb0 {uint8 transaction group index} {uint8 position in scratch space to store to}
-- Pops: _None_
-- Pushes: any
-- push Ith scratch space index of the Tth transaction in the current group
-- LogicSigVersion >= 2

data/transactions/logic/doc.go

@@ -82,6 +82,7 @@ var opDocByName = map[string]string{
 	"load":              "copy a value from scratch space to the stack",
 	"store":             "pop a value from the stack and store to scratch space",
 	"gload":             "push Ith scratch space index of the Tth transaction in the current group",
+	"gloads":            "push Ith scratch space index of the Ath transaction in the current group",
 	"bnz":               "branch to TARGET if value X is not zero",
 	"bz":                "branch to TARGET if value X is zero",
 	"b":                 "branch unconditionally to TARGET",
@@ -142,7 +143,8 @@ var opcodeImmediateNotes = map[string]string{
 	"b":                 "{int16 branch offset, big endian. (negative offsets are illegal before v4)}",
 	"load":              "{uint8 position in scratch space to load from}",
 	"store":             "{uint8 position in scratch space to store to}",
-	"gload":             "{uint8 transaction group index} {uint8 position in scratch space to store to}",
+	"gload":             "{uint8 transaction group index} {uint8 position in scratch space to load from}",
+	"gloads":            "{uint8 position in scratch space to load from}",
 	"substring":         "{uint8 start position} {uint8 end position}",
 	"dig":               "{uint8 depth}",
 	"asset_holding_get": "{uint8 asset holding field index}",
@@ -203,7 +205,7 @@ type OpGroup struct {
 // OpGroupList is groupings of ops for documentation purposes.
 var OpGroupList = []OpGroup{
 	{"Arithmetic", []string{"sha256", "keccak256", "sha512_256", "ed25519verify", "+", "-", "/", "*", "<", ">", "<=", ">=", "&&", "||", "==", "!=", "!", "len", "itob", "btoi", "%", "|", "&", "^", "~", "mulw", "addw", "divw", "getbit", "setbit", "getbyte", "setbyte", "concat", "substring", "substring3"}},
-	{"Loading Values", []string{"intcblock", "intc", "intc_0", "intc_1", "intc_2", "intc_3", "pushint", "bytecblock", "bytec", "bytec_0", "bytec_1", "bytec_2", "bytec_3", "pushbytes", "arg", "arg_0", "arg_1", "arg_2", "arg_3", "txn", "gtxn", "txna", "gtxna", "gtxns", "gtxnsa", "global", "load", "store", "gload"}},
+	{"Loading Values", []string{"intcblock", "intc", "intc_0", "intc_1", "intc_2", "intc_3", "pushint", "bytecblock", "bytec", "bytec_0", "bytec_1", "bytec_2", "bytec_3", "pushbytes", "arg", "arg_0", "arg_1", "arg_2", "arg_3", "txn", "gtxn", "txna", "gtxna", "gtxns", "gtxnsa", "global", "load", "store", "gload", "gloads"}},
 	{"Flow Control", []string{"err", "bnz", "bz", "b", "return", "pop", "dup", "dup2", "dig", "swap", "select", "assert", "callsub", "retsub"}},
 	{"State Access", []string{"balance", "min_balance", "app_opted_in", "app_local_get", "app_local_get_ex", "app_global_get", "app_global_get_ex", "app_local_put", "app_global_put", "app_local_del", "app_global_del", "asset_holding_get", "asset_params_get"}},
 }

data/transactions/logic/eval.go

@@ -1911,34 +1911,56 @@ func opStore(cx *evalContext) {
 	cx.stack = cx.stack[:last]
 }
 
-func opGload(cx *evalContext) {
-	gtxid := int(uint(cx.program[cx.pc+1]))
-	if gtxid >= len(cx.TxnGroup) {
-		cx.err = fmt.Errorf("gload lookup TxnGroup[%d] but it only has %d", gtxid, len(cx.TxnGroup))
+func opGloadImpl(cx *evalContext, groupIdx int, scratchIdx int) (err error, scratchValue stackValue) {
+	if groupIdx >= len(cx.TxnGroup) {
+		err = fmt.Errorf("gload lookup TxnGroup[%d] but it only has %d", groupIdx, len(cx.TxnGroup))
 		return
-	}
-	txn := cx.TxnGroup[gtxid].Txn
-	gindex := int(uint(cx.program[cx.pc+2]))
-	if gindex >= 256 {
-		cx.err = fmt.Errorf("invalid Scratch index %d", gindex)
+	} else if scratchIdx >= 256 {
+		err = fmt.Errorf("invalid Scratch index %d", scratchIdx)
 		return
-	} else if txn.Type != protocol.ApplicationCallTx {
-		cx.err = fmt.Errorf("can't use gload on non-app call txn with index %d", gtxid)
+	} else if txn := cx.TxnGroup[groupIdx].Txn; txn.Type != protocol.ApplicationCallTx {
+		err = fmt.Errorf("can't use gload on non-app call txn with index %d", groupIdx)
 		return
 	} else if cx.runModeFlags == runModeSignature {
-		cx.err = fmt.Errorf("can't use gload from within a LogicSig")
+		err = fmt.Errorf("can't use gload from within a LogicSig")
+		return
+	} else if groupIdx == cx.GroupIndex {
+		err = fmt.Errorf("can't use gload on self, use load instead")
 		return
-	} else if gtxid == cx.GroupIndex {
-		cx.err = fmt.Errorf("can't use gload on self, use load instead")
+	} else if groupIdx > cx.GroupIndex {
+		err = fmt.Errorf("gload can't get future scratch space from txn with index %d", groupIdx)
 		return
-	} else if gtxid > cx.GroupIndex {
-		cx.err = fmt.Errorf("gload can't get future scratch space from txn with index %d", gtxid)
+	}
+
+	scratchValue = cx.PastSideEffects[groupIdx].GetScratchValue(uint8(scratchIdx))
+	return
+}
+
+func opGload(cx *evalContext) {
+	groupIdx := int(uint(cx.program[cx.pc+1]))
+	scratchIdx := int(uint(cx.program[cx.pc+2]))
+	err, scratchValue := opGloadImpl(cx, groupIdx, scratchIdx)
+	if err != nil {
+		cx.err = err
 		return
 	}
-	scratchValue := cx.PastSideEffects[gtxid].GetScratchValue(uint8(gindex))
+
 	cx.stack = append(cx.stack, scratchValue)
 }
 
+func opGloads(cx *evalContext) {
+	last := len(cx.stack) - 1
+	groupIdx := int(cx.stack[last].Uint)
+	scratchIdx := int(uint(cx.program[cx.pc+1]))
+	err, scratchValue := opGloadImpl(cx, groupIdx, scratchIdx)
+	if err != nil {
+		cx.err = err
+		return
+	}
+
+	cx.stack[last] = scratchValue
+}
+
 func opConcat(cx *evalContext) {
 	last := len(cx.stack) - 1
 	prev := last - 1

data/transactions/logic/opcodes.go

@@ -189,6 +189,9 @@ var OpSpecs = []OpSpec{
 	// Like gtxn, but gets txn index from stack, rather than immediate arg
 	{0x38, "gtxns", opGtxns, assembleGtxns, disTxn, oneInt, oneAny, 3, modeAny, immediates("f")},
 	{0x39, "gtxnsa", opGtxnsa, assembleGtxns, disTxna, oneInt, oneAny, 3, modeAny, immediates("f", "i")},
+	// Group scratch space access
+	{0x3a, "gload", opGload, asmDefault, disDefault, nil, oneAny, 4, runModeApplication, immediates("t", "i")},
+	{0x3b, "gloads", opGloads, asmDefault, disDefault, oneInt, oneAny, 4, runModeApplication, immediates("i")},
 
 	{0x40, "bnz", opBnz, assembleBranch, disBranch, oneInt, nil, 1, modeAny, opBranch},
 	{0x41, "bz", opBz, assembleBranch, disBranch, oneInt, nil, 2, modeAny, opBranch},
@@ -241,9 +244,6 @@ var OpSpecs = []OpSpec{
 	// shl, shr
 	// divw, modw convenience
 	// expmod
-
-	// Group scratch space access
-	{0xb0, "gload", opGload, asmDefault, disDefault, nil, oneAny, 2, modeAny, immediates("t", "i")},
 }
 
 type sortByOpcode []OpSpec