tealrb 0.6.0 → 0.9.0

data/lib/tealrb/opcodes.rb

@@ -41,621 +41,623 @@ module TEALrb
       '!': 'zero?'
     }.freeze
 
-    def acct_params_get(field, _account = nil)
-      TEALrb::TEAL.current[Thread.current] << "acct_params_get #{field}"
-    end
+    module TEALOpcodes
+      def acct_params_get(field, _account = nil)
+        TEAL.instance << "acct_params_get #{field}"
+      end
+
+      def add(_a = nil, _b = nil)
+        TEAL.instance << '+'
+      end
+
+      def addr(address)
+        TEAL.instance << "addr #{address}"
+      end
+
+      def addw(_a = nil, _b = nil)
+        TEAL.instance << 'addw'
+      end
+
+      def app_global_del(_key = nil)
+        TEAL.instance << 'app_global_del'
+      end
+
+      def app_global_get(_key = nil)
+        TEAL.instance << 'app_global_get'
+      end
+
+      def app_global_get_ex(_app = nil, _key = nil)
+        TEAL.instance << 'app_global_get_ex'
+      end
+
+      def app_global_put(_key = nil, _value = nil)
+        TEAL.instance << 'app_global_put'
+      end
+
+      def app_local_del(_account = nil, _key = nil)
+        TEAL.instance << 'app_local_del'
+      end
+
+      def app_local_get(_account = nil, _key = nil)
+        TEAL.instance << 'app_local_get'
+      end
+
+      def app_local_get_ex(_account = nil, _application = nil, _key = nil)
+        TEAL.instance << 'app_local_get_ex'
+      end
+
+      def app_local_put(_account = nil, _key = nil, _value = nil)
+        TEAL.instance << 'app_local_put'
+      end
+
+      def app_opted_in(_account = nil, _app = nil)
+        TEAL.instance << 'app_opted_in'
+      end
+
+      def app_params_get(field, _app_id = nil)
+        TEAL.instance << "app_params_get #{field}"
+      end
+
+      def approve
+        TEAL.instance << 'int 1'
+        TEAL.instance << 'return'
+      end
 
-    def add(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '+'
-    end
+      def arg(index)
+        TEAL.instance << "arg #{index}"
+      end
 
-    def addr(address)
-      TEALrb::TEAL.current[Thread.current] << "addr #{address}"
-    end
+      def arg_0 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'arg_0'
+      end
 
-    def addw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'addw'
-    end
+      def arg_1 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'arg_1'
+      end
 
-    def app_global_del(_key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_del'
-    end
+      def arg_2 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'arg_2'
+      end
 
-    def app_global_get(_key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_get'
-    end
+      def arg_3 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'arg_3'
+      end
 
-    def app_global_get_ex(_app = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_get_ex'
-    end
+      def args(_index = nil)
+        TEAL.instance << 'args'
+      end
 
-    def app_global_put(_key = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_global_put'
-    end
+      def assert(_expr = nil)
+        TEAL.instance << 'assert'
+      end
 
-    def app_local_del(_account = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_del'
-    end
+      def asset_holding_get(field, _account = nil, _asset = nil)
+        TEAL.instance << "asset_holding_get #{field}"
+      end
 
-    def app_local_get(_account = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_get'
-    end
+      def asset_params_get(field, _asset = nil)
+        TEAL.instance << "asset_params_get #{field}"
+      end
 
-    def app_local_get_ex(_account = nil, _application = nil, _key = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_get_ex'
-    end
+      def b(target)
+        TEAL.instance << "#{__method__} #{target}"
+      end
 
-    def app_local_put(_account = nil, _key = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_local_put'
-    end
+      def base32(input)
+        TEAL.instance << "byte base32(#{input})"
+      end
 
-    def app_opted_in(_account = nil, _app = nil)
-      TEALrb::TEAL.current[Thread.current] << 'app_opted_in'
-    end
+      def balance(_account = nil)
+        TEAL.instance << 'balance'
+      end
 
-    def app_params_get(field, _app_id = nil)
-      TEALrb::TEAL.current[Thread.current] << "app_params_get #{field}"
-    end
+      def big_endian_add(_a = nil, _b = nil)
+        TEAL.instance << 'b+'
+      end
 
-    def approve
-      TEALrb::TEAL.current[Thread.current] << 'int 1'
-      TEALrb::TEAL.current[Thread.current] << 'return'
-    end
+      def big_endian_divide(_a = nil, _b = nil)
+        TEAL.instance << 'b/'
+      end
 
-    def arg(index)
-      TEALrb::TEAL.current[Thread.current] << "arg #{index}"
-    end
+      def big_endian_equal(_a = nil, _b = nil)
+        TEAL.instance << 'b=='
+      end
 
-    def arg_0 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_0'
-    end
+      def big_endian_less(_a = nil, _b = nil)
+        TEAL.instance << 'b<'
+      end
 
-    def arg_1 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_1'
-    end
+      def big_endian_less_eq(_a = nil, _b = nil)
+        TEAL.instance << 'b<='
+      end
 
-    def arg_2 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_2'
-    end
+      def big_endian_modulo(_a = nil, _b = nil)
+        TEAL.instance << 'b%'
+      end
 
-    def arg_3 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'arg_3'
-    end
+      def big_endian_more(_a = nil, _b = nil)
+        TEAL.instance << 'b>'
+      end
 
-    def args(_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'args'
-    end
+      def big_endian_more_eq(_a = nil, _b = nil)
+        TEAL.instance << 'b>='
+      end
 
-    def assert(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'assert'
-    end
+      def big_endian_multiply(_a = nil, _b = nil)
+        TEAL.instance << 'b*'
+      end
 
-    def asset_holding_get(field, _account = nil, _asset = nil)
-      TEALrb::TEAL.current[Thread.current] << "asset_holding_get #{field}"
-    end
+      def big_endian_not_equal(_a = nil, _b = nil)
+        TEAL.instance << 'b!='
+      end
 
-    def asset_params_get(field, _asset = nil)
-      TEALrb::TEAL.current[Thread.current] << "asset_params_get #{field}"
-    end
+      def big_endian_subtract(_a = nil, _b = nil)
+        TEAL.instance << 'b-'
+      end
 
-    def b(target)
-      TEALrb::TEAL.current[Thread.current] << "#{__method__} #{target}"
-    end
+      def bitlen(_input = nil)
+        TEAL.instance << 'bitlen'
+      end
 
-    def base32(input)
-      TEALrb::TEAL.current[Thread.current] << "byte base32(#{input})"
-    end
+      def bitwise_and(_a = nil, _b = nil)
+        TEAL.instance << '&'
+      end
 
-    def balance(_account = nil)
-      TEALrb::TEAL.current[Thread.current] << 'balance'
-    end
+      def bitwise_byte_invert(_a = nil, _b = nil)
+        TEAL.instance << 'b~'
+      end
 
-    def big_endian_add(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b+'
-    end
+      def bitwise_invert(_a = nil, _b = nil)
+        TEAL.instance << '~'
+      end
 
-    def big_endian_divide(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b/'
-    end
+      def bitwise_or(_a = nil, _b = nil)
+        TEAL.instance << '|'
+      end
 
-    def big_endian_equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b=='
-    end
+      def bitwise_xor(_a = nil, _b = nil)
+        TEAL.instance << '^'
+      end
 
-    def big_endian_less(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b<'
-    end
+      def bnz(target)
+        TEAL.instance << "#{__method__} #{target}"
+      end
 
-    def big_endian_less_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b<='
-    end
+      def bsqrt(_big_endian_uint = nil)
+        TEAL.instance << 'bsqrt'
+      end
 
-    def big_endian_modulo(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b%'
-    end
+      def btoi(_bytes = nil)
+        TEAL.instance << 'btoi'
+      end
 
-    def big_endian_more(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b>'
-    end
+      def byte(string)
+        TEAL.instance << "byte \"#{string}\""
+      end
 
-    def big_endian_more_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b>='
-    end
+      def bytec(index)
+        TEAL.instance << "bytec #{index}"
+      end
 
-    def big_endian_multiply(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b*'
-    end
+      def bytec_0 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'bytec_0'
+      end
 
-    def big_endian_not_equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b!='
-    end
+      def bytec_1 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'bytec_1'
+      end
 
-    def big_endian_subtract(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b-'
-    end
+      def bytec_2 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'bytec_2'
+      end
 
-    def bitlen(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'bitlen'
-    end
+      def bytec_3 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'bytec_3'
+      end
 
-    def bitwise_and(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '&'
-    end
+      def bytecblock(*bytes)
+        TEAL.instance << "bytecblock #{bytes.join(' ')}"
+      end
 
-    def bitwise_byte_invert(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b~'
-    end
+      def bz(target)
+        TEAL.instance << "#{__method__} #{target}"
+      end
 
-    def bitwise_invert(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '~'
-    end
+      def bzero(_length = nil)
+        TEAL.instance << 'bzero'
+      end
 
-    def bitwise_or(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '|'
-    end
+      def callsub(name, *_args)
+        TEAL.instance << "callsub #{name}"
+      end
 
-    def bitwise_xor(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '^'
-    end
+      def concat(_a = nil, _b = nil)
+        TEAL.instance << 'concat'
+      end
 
-    def bnz(target)
-      TEALrb::TEAL.current[Thread.current] << "#{__method__} #{target}"
-    end
+      def cover(count)
+        TEAL.instance << "cover #{count}"
+      end
 
-    def bsqrt(_big_endian_uint = nil)
-      TEALrb::TEAL.current[Thread.current] << 'bsqrt'
-    end
+      def dig(index)
+        TEAL.instance << "dig #{index}"
+      end
 
-    def btoi(_bytes = nil)
-      TEALrb::TEAL.current[Thread.current] << 'btoi'
-    end
+      def divide(_a = nil, _b = nil)
+        TEAL.instance << '/'
+      end
 
-    def byte(string)
-      TEALrb::TEAL.current[Thread.current] << "byte \"#{string}\""
-    end
+      def divmodw(_a = nil, _b = nil)
+        TEAL.instance << 'divmodw'
+      end
 
-    def bytec(index)
-      TEALrb::TEAL.current[Thread.current] << "bytec #{index}"
-    end
+      def divw(_a = nil, _b = nil)
+        TEAL.instance << 'divw'
+      end
 
-    def bytec_0 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_0'
-    end
+      def dup(_expr = nil)
+        TEAL.instance << 'dup'
+      end
 
-    def bytec_1 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_1'
-    end
+      def dup2(_expr_a = nil, _expr_b = nil)
+        TEAL.instance << 'dup2'
+      end
 
-    def bytec_2 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_2'
-    end
+      def ecdsa_pk_decompress(index, _input = nil)
+        TEAL.instance << "ecdsa_pk_decompress #{index}"
+      end
 
-    def bytec_3 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'bytec_3'
-    end
+      def ecdsa_pk_recover(index, _input = nil)
+        TEAL.instance << "ecdsa_pk_recover #{index}"
+      end
 
-    def bytecblock(*bytes)
-      TEALrb::TEAL.current[Thread.current] << "bytecblock #{bytes.join(' ')}"
-    end
+      def ecdsa_verify(index, _input = nil)
+        TEAL.instance << "ecdsa_verify #{index}"
+      end
 
-    def bz(target)
-      TEALrb::TEAL.current[Thread.current] << "#{__method__} #{target}"
-    end
+      def ed25519verify(_input = nil)
+        TEAL.instance << 'ed25519verify'
+      end
 
-    def bzero(_length = nil)
-      TEALrb::TEAL.current[Thread.current] << 'bzero'
-    end
+      def equal(_a = nil, _b = nil)
+        TEAL.instance << '=='
+      end
 
-    def callsub(name, *_args)
-      TEALrb::TEAL.current[Thread.current] << "callsub #{name}"
-    end
+      def err
+        TEAL.instance << 'err'
+      end
 
-    def concat(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'concat'
-    end
+      def exp(_a = nil, _b = nil)
+        TEAL.instance << 'exp'
+      end
 
-    def cover(count)
-      TEALrb::TEAL.current[Thread.current] << "cover #{count}"
-    end
+      def expw(_a = nil, _b = nil)
+        TEAL.instance << 'expw'
+      end
 
-    def dig(index)
-      TEALrb::TEAL.current[Thread.current] << "dig #{index}"
-    end
+      def extract(start, length, _byte_array = nil)
+        TEAL.instance << "extract #{start} #{length}"
+      end
 
-    def divide(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '/'
-    end
+      def extract3(_byte_array = nil, _start = nil, _exclusive_end = nil)
+        TEAL.instance << 'extract3'
+      end
 
-    def divmodw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'divmodw'
-    end
+      def extract_uint16(_byte_array = nil, _start = nil)
+        TEAL.instance << 'extract_uint16'
+      end
 
-    def divw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'divw'
-    end
+      def extract_uint32(_byte_array = nil, _start = nil)
+        TEAL.instance << 'extract_uint32'
+      end
 
-    def dup(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'dup'
-    end
+      def extract_uint64(_byte_array = nil, _start = nil)
+        TEAL.instance << 'extract_uint64'
+      end
 
-    def dup2(_expr_a = nil, _expr_b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'dup2'
-    end
+      def gaid(transaction_index)
+        TEAL.instance << "gaid #{transaction_index}"
+      end
 
-    def ecdsa_pk_decompress(index, _input = nil)
-      TEALrb::TEAL.current[Thread.current] << "ecdsa_pk_decompress #{index}"
-    end
+      def gaids(_transaction = nil)
+        TEAL.instance << 'gaids'
+      end
 
-    def ecdsa_pk_recover(index, _input = nil)
-      TEALrb::TEAL.current[Thread.current] << "ecdsa_pk_recover #{index}"
-    end
+      def getbit(_input = nil, _bit_index = nil)
+        TEAL.instance << 'getbit'
+      end
 
-    def ecdsa_verify(index, _input = nil)
-      TEALrb::TEAL.current[Thread.current] << "ecdsa_verify #{index}"
-    end
+      def getbyte(_input = nil, _byte_index = nil)
+        TEAL.instance << 'getbyte'
+      end
 
-    def ed25519verify(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'ed25519verify'
-    end
+      def gitxn(transaction_index, field)
+        TEAL.instance << "gitxn #{transaction_index} #{field}"
+      end
 
-    def equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '=='
-    end
+      def gitxna(transaction_index, field, index)
+        TEAL.instance << "gitxna #{transaction_index} #{field} #{index}"
+      end
 
-    def err
-      TEALrb::TEAL.current[Thread.current] << 'err'
-    end
+      def gitxnas(transaction_index, field, _index = nil)
+        TEAL.instance << "gitxnas #{transaction_index} #{field}"
+      end
 
-    def exp(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'exp'
-    end
+      def gload(transaction_index, index)
+        TEAL.instance << "gload #{transaction_index} #{index}"
+      end
 
-    def expw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'expw'
-    end
+      def gloads(index, _transaction_index = nil)
+        TEAL.instance << "gloads #{index}"
+      end
 
-    def extract(start, length, _byte_array = nil)
-      TEALrb::TEAL.current[Thread.current] << "extract #{start} #{length}"
-    end
+      def gloadss(_transaction = nil, _index = nil)
+        TEAL.instance << 'gloadss'
+      end
 
-    def extract3(_byte_array = nil, _start = nil, _exclusive_end = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract3'
-    end
+      def global(field)
+        TEAL.instance << "global #{field}"
+      end
 
-    def extract_uint16(_byte_array = nil, _start = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract_uint16'
-    end
+      def greater(_a = nil, _b = nil)
+        TEAL.instance << '>'
+      end
 
-    def extract_uint32(_byte_array = nil, _start = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract_uint32'
-    end
+      def greater_eq(_a = nil, _b = nil)
+        TEAL.instance << '>='
+      end
 
-    def extract_uint64(_byte_array = nil, _start = nil)
-      TEALrb::TEAL.current[Thread.current] << 'extract_uint64'
-    end
+      def gtxn(index, field)
+        TEAL.instance << "gtxn #{index} #{field}"
+      end
 
-    def gaid(transaction_index)
-      TEALrb::TEAL.current[Thread.current] << "gaid #{transaction_index}"
-    end
+      def gtxna(transaction_index, field, index)
+        TEAL.instance << "gtxna #{transaction_index} #{field} #{index}"
+      end
 
-    def gaids(_transaction = nil)
-      TEALrb::TEAL.current[Thread.current] << 'gaids'
-    end
+      def gtxns(field, _transaction_index = nil)
+        TEAL.instance << "gtxns #{field}"
+      end
 
-    def getbit(_input = nil, _bit_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'getbit'
-    end
+      def gtxnsa(field, index, _transaction_index = nil)
+        TEAL.instance << "gtxnsa #{field} #{index}"
+      end
 
-    def getbyte(_input = nil, _byte_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'getbyte'
-    end
+      def gtxnas(transaction_index, field, _index = nil)
+        TEAL.instance << "gtxnas #{transaction_index} #{field}"
+      end
 
-    def gitxn(transaction_index, field)
-      TEALrb::TEAL.current[Thread.current] << "gitxn #{transaction_index} #{field}"
-    end
+      def gtxnsas(field, _transaction_index = nil, _index = nil)
+        TEAL.instance << "gtxnsas #{field}"
+      end
 
-    def gitxna(transaction_index, field, index)
-      TEALrb::TEAL.current[Thread.current] << "gitxna #{transaction_index} #{field} #{index}"
-    end
+      def int(integer)
+        TEAL.instance << "int #{integer}"
+      end
 
-    def gitxnas(transaction_index, field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gitxnas #{transaction_index} #{field}"
-    end
+      def intc(index)
+        TEAL.instance << "intc #{index}"
+      end
 
-    def gload(transaction_index, index)
-      TEALrb::TEAL.current[Thread.current] << "gload #{transaction_index} #{index}"
-    end
+      def intc_0 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'intc_0'
+      end
 
-    def gloads(index, _transaction_index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gloads #{index}"
-    end
+      def intc_1 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'intc_1'
+      end
 
-    def gloadss(_transaction = nil, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'gloadss'
-    end
+      def intc_2 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'intc_2'
+      end
 
-    def global(field)
-      TEALrb::TEAL.current[Thread.current] << "global #{field}"
-    end
+      def intc_3 # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'intc_3'
+      end
 
-    def greater(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '>'
-    end
+      def intcblock(*ints)
+        TEAL.instance << "intcblock #{ints.join(' ')}"
+      end
 
-    def greater_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '>='
-    end
+      def itob(_bytes = nil)
+        TEAL.instance << 'itob'
+      end
 
-    def gtxn(index, field)
-      TEALrb::TEAL.current[Thread.current] << "gtxn #{index} #{field}"
-    end
+      def itxn_begin
+        TEAL.instance << 'itxn_begin'
+      end
 
-    def gtxna(transaction_index, field, index)
-      TEALrb::TEAL.current[Thread.current] << "gtxna #{transaction_index} #{field} #{index}"
-    end
+      def itxn_field(field, _value = nil)
+        TEAL.instance << "itxn_field #{field}"
+      end
 
-    def gtxns(field, _transaction_index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxns #{field}"
-    end
+      def itxn_next
+        TEAL.instance << 'itxn_next'
+      end
 
-    def gtxnsa(field, index, _transaction_index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxnsa #{field} #{index}"
-    end
+      def itxn_submit
+        TEAL.instance << 'itxn_submit'
+      end
 
-    def gtxnas(transaction_index, field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxnas #{transaction_index} #{field}"
-    end
+      def itxna(field, index)
+        TEAL.instance << "itxna #{field} #{index}"
+      end
 
-    def gtxnsas(field, _transaction_index = nil, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "gtxnsas #{field}"
-    end
+      def itxnas(field, _index = nil)
+        TEAL.instance << "itxnas #{field}"
+      end
 
-    def int(integer)
-      TEALrb::TEAL.current[Thread.current] << "int #{integer}"
-    end
+      def keccak256(_input = nil)
+        TEAL.instance << 'keccak256'
+      end
 
-    def intc(index)
-      TEALrb::TEAL.current[Thread.current] << "intc #{index}"
-    end
+      def label(label_name)
+        TEAL.instance << "#{label_name}:"
+      end
 
-    def intc_0 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_0'
-    end
+      def len(_input = nil)
+        TEAL.instance << 'len'
+      end
 
-    def intc_1 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_1'
-    end
+      def less(_a = nil, _b = nil)
+        TEAL.instance << '<'
+      end
 
-    def intc_2 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_2'
-    end
+      def less_eq(_a = nil, _b = nil)
+        TEAL.instance << '<='
+      end
 
-    def intc_3 # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'intc_3'
-    end
+      def load(index)
+        TEAL.instance << "load #{index}"
+      end
 
-    def intcblock(*ints)
-      TEALrb::TEAL.current[Thread.current] << "intcblock #{ints.join(' ')}"
-    end
+      def loads(_index = nil)
+        TEAL.instance << 'loads'
+      end
 
-    def itob(_bytes = nil)
-      TEALrb::TEAL.current[Thread.current] << 'itob'
-    end
+      def log(_byte_array = nil)
+        TEAL.instance << 'log'
+      end
 
-    def itxn_begin
-      TEALrb::TEAL.current[Thread.current] << 'itxn_begin'
-    end
+      def method_signature(signature)
+        TEAL.instance << %(method "#{signature}")
+      end
 
-    def itxn_field(field, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << "itxn_field #{field}"
-    end
+      def min_balance(_account = nil)
+        TEAL.instance << 'min_balance'
+      end
 
-    def itxn_next
-      TEALrb::TEAL.current[Thread.current] << 'itxn_next'
-    end
+      def modulo(_a = nil, _b = nil)
+        TEAL.instance << '%'
+      end
 
-    def itxn_submit
-      TEALrb::TEAL.current[Thread.current] << 'itxn_submit'
-    end
+      def multiply(_a = nil, _b = nil)
+        TEAL.instance << '*'
+      end
 
-    def itxna(field, index)
-      TEALrb::TEAL.current[Thread.current] << "itxna #{field} #{index}"
-    end
+      def mulw(_a = nil, _b = nil)
+        TEAL.instance << 'mulw'
+      end
 
-    def itxnas(field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "itxnas #{field}"
-    end
+      def zero?(_expr = nil)
+        TEAL.instance << '!'
+      end
 
-    def keccak256(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'keccak256'
-    end
+      def not_equal(_a = nil, _b = nil)
+        TEAL.instance << '!='
+      end
 
-    def label(label_name)
-      TEALrb::TEAL.current[Thread.current] << "#{label_name}:"
-    end
+      def padded_bitwise_and(_a = nil, _b = nil)
+        TEAL.instance << 'b&'
+      end
 
-    def len(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'len'
-    end
+      def padded_bitwise_or(_a = nil, _b = nil)
+        TEAL.instance << 'b|'
+      end
 
-    def less(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '<'
-    end
+      def padded_bitwise_xor(_a = nil, _b = nil)
+        TEAL.instance << 'b^'
+      end
 
-    def less_eq(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '<='
-    end
+      def pop(_expr = nil)
+        TEAL.instance << 'pop'
+      end
 
-    def load(index)
-      TEALrb::TEAL.current[Thread.current] << "load #{index}"
-    end
+      def pushbytes(string)
+        TEAL.instance << "pushbytes \"#{string}\""
+      end
 
-    def loads(_index = nil)
-      TEALrb::TEAL.current[Thread.current] << 'loads'
-    end
+      def pushint(integer)
+        TEAL.instance << "pushint #{integer}"
+      end
 
-    def log(_byte_array = nil)
-      TEALrb::TEAL.current[Thread.current] << 'log'
-    end
+      def retsub
+        TEAL.instance << 'retsub'
+      end
 
-    def method_signature(signature)
-      TEALrb::TEAL.current[Thread.current] << %(method "#{signature}")
-    end
+      def select(_expr_a = nil, _expr_b = nil, _expr_c = nil)
+        TEAL.instance << 'select'
+      end
 
-    def min_balance(_account = nil)
-      TEALrb::TEAL.current[Thread.current] << 'min_balance'
-    end
+      def setbit(_input = nil, _bit_index = nil, _value = nil)
+        TEAL.instance << 'setbit'
+      end
 
-    def modulo(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '%'
-    end
+      def setbyte(_byte_array = nil, _byte_index = nil, _value = nil)
+        TEAL.instance << 'setbyte'
+      end
 
-    def multiply(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '*'
-    end
+      def sha256(_input = nil)
+        TEAL.instance << 'sha256'
+      end
 
-    def mulw(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'mulw'
-    end
+      def sha512_256(_input = nil) # rubocop:disable Naming/VariableNumber
+        TEAL.instance << 'sha512_256'
+      end
 
-    def zero?(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << '!'
-    end
+      def shl(_a = nil, _b = nil)
+        TEAL.instance << 'shl'
+      end
 
-    def not_equal(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '!='
-    end
+      def shr(_a = nil, _b = nil)
+        TEAL.instance << 'shr'
+      end
 
-    def padded_bitwise_and(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b&'
-    end
+      def sqrt(_integer = nil)
+        TEAL.instance << 'sqrt'
+      end
 
-    def padded_bitwise_or(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b|'
-    end
+      def store(index, _value = nil)
+        TEAL.instance << "store #{index}"
+      end
 
-    def padded_bitwise_xor(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'b^'
-    end
+      def stores(_index = nil, _value = nil)
+        TEAL.instance << 'stores'
+      end
 
-    def pop(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'pop'
-    end
+      def substring(start, exclusive_end, _byte_array = nil)
+        TEAL.instance << "substring #{start} #{exclusive_end}"
+      end
 
-    def pushbytes(string)
-      TEALrb::TEAL.current[Thread.current] << "pushbytes \"#{string}\""
-    end
+      def substring3(_byte_array = nil, _start = nil, _exclusive_end = nil)
+        TEAL.instance << 'substring3'
+      end
 
-    def pushint(integer)
-      TEALrb::TEAL.current[Thread.current] << "pushint #{integer}"
-    end
+      def subtract(_a = nil, _b = nil)
+        TEAL.instance << '-'
+      end
 
-    def retsub
-      TEALrb::TEAL.current[Thread.current] << 'retsub'
-    end
+      def swap(_expr_a = nil, _expr_b = nil)
+        TEAL.instance << 'swap'
+      end
 
-    def select(_expr_a = nil, _expr_b = nil, _expr_c = nil)
-      TEALrb::TEAL.current[Thread.current] << 'select'
-    end
+      def teal_return(_expr = nil)
+        TEAL.instance << 'return'
+      end
 
-    def setbit(_input = nil, _bit_index = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'setbit'
-    end
+      def txn(field)
+        TEAL.instance << "txn #{field}"
+      end
 
-    def setbyte(_byte_array = nil, _byte_index = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'setbyte'
-    end
+      def txna(field, index)
+        TEAL.instance << "txna #{field} #{index}"
+      end
 
-    def sha256(_input = nil)
-      TEALrb::TEAL.current[Thread.current] << 'sha256'
-    end
+      def txnas(field, _index = nil)
+        TEAL.instance << "txnas #{field}"
+      end
 
-    def sha512_256(_input = nil) # rubocop:disable Naming/VariableNumber
-      TEALrb::TEAL.current[Thread.current] << 'sha512_256'
-    end
-
-    def shl(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'shl'
-    end
-
-    def shr(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'shr'
-    end
+      def uncover(count)
+        TEAL.instance << "uncover #{count}"
+      end
 
-    def sqrt(_integer = nil)
-      TEALrb::TEAL.current[Thread.current] << 'sqrt'
-    end
-
-    def store(index, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << "store #{index}"
-    end
-
-    def stores(_index = nil, _value = nil)
-      TEALrb::TEAL.current[Thread.current] << 'stores'
-    end
-
-    def substring(start, exclusive_end, _byte_array = nil)
-      TEALrb::TEAL.current[Thread.current] << "substring #{start} #{exclusive_end}"
-    end
-
-    def substring3(_byte_array = nil, _start = nil, _exclusive_end = nil)
-      TEALrb::TEAL.current[Thread.current] << 'substring3'
-    end
-
-    def subtract(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '-'
-    end
-
-    def swap(_expr_a = nil, _expr_b = nil)
-      TEALrb::TEAL.current[Thread.current] << 'swap'
-    end
-
-    def teal_return(_expr = nil)
-      TEALrb::TEAL.current[Thread.current] << 'return'
-    end
-
-    def txn(field)
-      TEALrb::TEAL.current[Thread.current] << "txn #{field}"
-    end
-
-    def txna(field, index)
-      TEALrb::TEAL.current[Thread.current] << "txna #{field} #{index}"
-    end
-
-    def txnas(field, _index = nil)
-      TEALrb::TEAL.current[Thread.current] << "txnas #{field}"
-    end
-
-    def uncover(count)
-      TEALrb::TEAL.current[Thread.current] << "uncover #{count}"
-    end
-
-    def boolean_and(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '&&'
-    end
+      def boolean_and(_a = nil, _b = nil)
+        TEAL.instance << '&&'
+      end
 
-    def boolean_or(_a = nil, _b = nil)
-      TEALrb::TEAL.current[Thread.current] << '||'
+      def boolean_or(_a = nil, _b = nil)
+        TEAL.instance << '||'
+      end
     end
   end
 end