tealrb 0.10.1 → 0.12.0

data/lib/tealrb/contract.rb

@@ -3,91 +3,104 @@
 module TEALrb
   class Contract
     include TEALrb
-    include Opcodes
-    include Opcodes::AllOpcodes
+    include Opcodes::TEALOpcodes
+    include MaybeOps
+    include ByteOpcodes
     include ABI
     include Rewriters
+    include Enums
 
-    attr_reader :teal
+    alias global_opcode global
 
-    class << self
-      attr_accessor :subroutines, :version, :teal_methods, :abi_method_hash, :abi_description, :debug,
-                    :disable_abi_routing
+    attr_reader :eval_location
+    attr_accessor :teal, :if_count
 
-      private
+    class << self
+      attr_accessor :subroutines, :version, :abi_interface, :debug,
+                    :disable_abi_routing, :method_hashes, :src_map
 
       def inherited(klass)
         klass.version = 6
         klass.subroutines = {}
-        klass.teal_methods = {}
-        klass.abi_description = ABI::ABIDescription.new
-        klass.abi_method_hash = {}
+        klass.abi_interface = ABI::ABIDescription.new
+        klass.abi_interface.name = klass.to_s
+        klass.method_hashes = []
         klass.debug = false
         klass.disable_abi_routing = false
+        klass.src_map = true
         super
       end
-    end
 
-    # abi description for the method
-    def self.abi(desc:, args:, returns:)
-      args = args.map do |name, h|
-        h[:name] = name.to_s
-        h[:type] = h[:type].to_s.split('::').last.downcase
-        h
-      end
+      def parse(klass)
+        YARD::Tags::Library.define_tag('ABI Method', :abi)
+        YARD::Tags::Library.define_tag('Subroutine', :subroutine)
+        YARD::Tags::Library.define_tag('OnCompletes', :on_completion)
+        YARD::Tags::Library.define_tag('Create', :create)
+
+        YARD.parse Object.const_source_location(klass.to_s).first
+
+        parsed_methods = {}
+        YARD::Registry.all.each do |y|
+          next unless y.type == :method
+          next unless klass.instance_methods.include? y.name
+          next if y.parent.type == :class && y.parent.to_s != klass.to_s
+
+          if parsed_methods.keys.include? y.name
+            raise "#{y.name} defined in two locations: \n  #{parsed_methods[y.name]}\n  #{y.file}:#{y.line}"
+          end
+
+          parsed_methods[y.name] = "#{y.file}:#{y.line}"
+
+          tags = y.tags.map(&:tag_name)
 
-      self.abi_method_hash = { desc: desc, args: args, returns: returns.to_s.split('::').last.downcase }
+          next unless tags.include?('abi') || tags.include?('subroutine')
+
+          method_hash = { name: y.name.to_s, desc: y.base_docstring, args: [], returns: { type: 'void' },
+                          on_completion: ['NoOp'], create: y.has_tag?('create') }
+
+          y.tags.each do |t|
+            method_hash[:returns] = { type: t.types&.first&.downcase } if t.tag_name == 'return'
+
+            method_hash[:on_completion] = t.text[1..-2].split(',').map(&:strip) if t.tag_name == 'on_completion'
+            next unless t.tag_name == 'param'
+
+            method_hash[:args] << { name: t.name, type: t.types&.first&.downcase, desc: t.text }
+          end
+
+          klass.method_hashes << method_hash
+
+          klass.abi_interface.add_method(**method_hash) if tags.include? 'abi'
+        end
+      end
     end
 
-    # specifies a TEAL subroutine that will be defined upon intialization
-    # @return [nil]
-    # @overload subroutine(name)
-    #  @param name [Symbol] name of the subroutine and the method to use as the subroutine definition
-    #
-    # @overload subroutine(name)
-    #  @param name [Symbol] name of the subroutine
-    #
-    #  @yield [*args] the definition of the subroutine
-    def self.subroutine(name, &blk)
-      @subroutines[name] = (blk || instance_method(name))
-      abi_description.add_method(**({ name: name.to_s }.merge abi_method_hash)) unless abi_method_hash.empty?
-      @abi_method_hash = {}
-      nil
+    TEALrb::Opcodes::BINARY_OPCODE_METHOD_MAPPING.each do |meth, opcode|
+      define_method(meth) do |other|
+        @contract.send(opcode, self, other)
+      end
     end
 
-    # specifies a method to be defined upon intialization that will be transpiled to TEAL when called
-    # @return [nil]
-    # @overload subroutine(name)
-    #  @param name [Symbol] name of the method to use as the TEAL definition
-    #
-    # @overload subroutine(name)
-    #  @param name [Symbol] name of the method
-    #
-    #  @yield [*args] the definition of the TEAL method
-    def self.teal(name, &blk)
-      @teal_methods[name] = (blk || instance_method(name))
-      nil
+    TEALrb::Opcodes::UNARY_OPCODE_METHOD_MAPPING.each do |meth, opcode|
+      define_method(meth) do
+        @contract.send(opcode, self)
+      end
     end
 
     # sets the `#pragma version`, defines teal methods, and defines subroutines
     def initialize
-      @teal = TEAL.new ["#pragma version #{self.class.version}"]
-      IfBlock.id = 0
-      @scratch = Scratch.new
+      self.class.parse(self.class)
 
-      self.class.subroutines.each_key do |name|
-        define_singleton_method(name) do |*_args|
-          callsub(name)
-        end
-      end
+      @teal = TEAL.new ["#pragma version #{self.class.version}"], self
+      @scratch = Scratch.new self
 
-      self.class.subroutines.each do |name, blk|
-        define_subroutine name, blk
-      end
+      @contract = self
+      @if_count = 0
 
-      self.class.teal_methods.each do |name, blk|
-        define_teal_method name, blk
+      self.class.method_hashes.each do |mh|
+        define_subroutine(mh[:name], method(mh[:name]))
       end
+
+      compile
     end
 
     VOID_OPS = %w[assert err return app_global_put b bnz bz store
@@ -95,47 +108,209 @@ module TEALrb
                   log itxn_submit itxn_next].freeze
 
     def teal_source
-      teal_lines = []
+      @teal.compact.join("\n")
+    end
 
-      @teal.each_with_index do |line, i|
-        ln = line.strip
+    def account(_account = nil)
+      @account ||= Account.new self
+    end
 
-        teal_lines << '' if i != 0 && VOID_OPS.include?(@teal[i - 1][/\S+/])
+    alias accounts account
 
-        if (ln[%r{\S+:($| //)}] && !ln[/^if\d+/]) || ln == 'b main' || ln[/^#/]
-          teal_lines << ln
-        elsif ln == 'retsub'
-          teal_lines << "    #{ln}"
-          teal_lines << ''
-        else
-          teal_lines << "    #{ln}"
+    def app(_app = nil)
+      @app ||= App.new self
+    end
+
+    alias apps app
+
+    def asset(_asset = nil)
+      @asset ||= Asset.new self
+    end
+
+    alias assets asset
+
+    def group_txn(_group_txn = nil)
+      @group_txn ||= GroupTxn.new self
+    end
+
+    alias group_txns group_txn
+
+    def global(field = nil, *_args)
+      if field
+        global_opcode(field)
+      else
+        @global ||= Global.new self
+      end
+    end
+
+    def this_txn
+      ThisTxn.new self
+    end
+
+    def box
+      Box.new self
+    end
+
+    def inner_txn
+      InnerTxn.new self
+    end
+
+    def logs
+      Logs.new self
+    end
+
+    def app_args
+      AppArgs.new self
+    end
+
+    def local
+      Local.new self
+    end
+
+    def txn_type
+      TxnType.new self
+    end
+
+    def generate_source_map(src)
+      last_location = nil
+      src_map_hash = {}
+
+      src.each_line.with_index do |ln, i|
+        if ln[/src_map:/]
+          last_location = ln[/(?<=src_map:)\S+/]
+          next
         end
+
+        src_map_hash[i + 1] ||= { location: last_location } if last_location
       end
 
-      teal_lines.delete_if.with_index do |t, i|
-        t.empty? && teal_lines[i - 1].empty?
+      compile_response = Algod.new.compile(src)
+
+      case compile_response.status
+      when 400
+        msg = JSON.parse(compile_response.body)['message']
+        e_msg = StringIO.new
+        e_msg.puts 'Error(s) while attempting to compile TEAL'
+        msg.each_line do |ln|
+          teal_line = ln.split(':').first.to_i
+          ln_msg = ln.split(':')[1..].join(':').strip
+          next if ln_msg == '"0"'
+
+          if src_map_hash[teal_line]
+            e_msg.puts "  #{teal_line} - #{src_map_hash[teal_line][:location]}: #{ln_msg}"
+          else
+            e_msg.puts "  #{ln}"
+          end
+        end
+        raise e_msg.string
+      when 200
+        json_body = JSON.parse(compile_response.body)
+        pc_mapping = json_body['sourcemap']['mapping']
+
+        pc_array = pc_mapping.split(';').map do |v|
+          SourceMap::VLQ.decode_array(v)[2]
+        end
+
+        last_line = 1
+
+        line_to_pc = {}
+        pc_to_line = {}
+        pc_array.each_with_index do |line_delta, pc|
+          last_line += line_delta.to_i
+
+          next if last_line == 1
+
+          line_to_pc[last_line] ||= []
+          line_to_pc[last_line] << pc
+          pc_to_line[pc] = last_line
+        end
+
+        line_to_pc.each do |line, pcs|
+          src_map_hash[line][:pcs] = pcs if src_map_hash[line]
+        end
       end
 
-      teal_lines.join("\n")
+      src_map_hash
     end
 
-    # return the input without transpiling to TEAL
-    def rb(input)
-      input
+    def dump(directory = Dir.pwd, name: self.class.to_s.downcase, abi: true, src_map: true)
+      src = formatted_teal
+
+      File.write(File.join(directory, "#{name}.teal"), src)
+      File.write(File.join(directory, "#{name}.abi.json"), JSON.pretty_generate(abi_hash)) if abi
+
+      return unless src_map
+
+      src_map_json = JSON.pretty_generate(generate_source_map(src))
+      File.write(File.join(directory, "#{name}.src_map.json"), src_map_json)
     end
 
-    # defines a method that is transpiled to TEAL
-    # @param name [Symbol] name of the method
-    # @param definition [Lambda, Proc, UnboundMethod] the method definition
-    # @return [nil]
-    def define_teal_method(name, definition)
-      new_source = generate_method_source(name, definition)
+    def formatted_teal
+      new_lines = []
+      comments = []
 
-      define_singleton_method(name) do |*_args|
-        eval_tealrb(new_source, debug_context: "teal method: #{name}")
+      @teal.compact.each do |ln|
+        ln = ln.strip
+
+        next if ln.empty?
+
+        if ln[/^#pragma/]
+          new_lines << { text: ln, void: true, comments: comments }
+          comments = []
+        elsif ln[%r{^//}]
+          comments << ln
+        else
+          op = ln.split.first
+          label_regex = %r{\S+:($| //)}
+
+          label_type = label_number = label_end = nil
+
+          if ln[label_regex]
+            label_type = ln[/^if/] || ln[/^while/]
+            label_number = ln[/(?<=^if)\d+/] || ln[/(?<=^while)\d+/]
+            label_end = ln[/_end:/]
+          end
+
+          new_lines << { text: ln, void: VOID_OPS.include?(op), comments: comments, label: ln[label_regex],
+                         label_type: label_type, label_number: label_number, label_end: label_end }
+          comments = []
+        end
       end
 
-      nil
+      output = []
+      indent_level = 0
+      current_labels = { 'while' => [], 'if' => [] }
+
+      new_lines.each do |ln|
+        indent_level = 1 if ln[:label] && indent_level.zero? && !ln[:label_type]
+
+        if ln[:label_type]
+          indent_level += 1 unless current_labels[ln[:label_type]].include?(ln[:label_number])
+          current_labels[ln[:label_type]] << ln[:label_number]
+        end
+
+        ln_indent_level = indent_level
+        ln_indent_level -= 1 if ln[:label]
+
+        output << '' if !output.last&.empty? && (ln[:label] || ln[:comments].any?)
+
+        ln[:comments].each { output << (("\t" * ln_indent_level) + _1) }
+        output << (("\t" * ln_indent_level) + ln[:text])
+
+        output << '' if ln[:void] && !output.last.empty?
+
+        next unless ln[:label_end]
+
+        indent_level -= 1
+        current_labels[ln[:label_type]].delete ln[:label_number]
+      end
+
+      output.join("\n")
+    end
+
+    # return the input without transpiling to TEAL
+    def rb(input)
+      input
     end
 
     # defines a TEAL subroutine
@@ -143,11 +318,15 @@ module TEALrb
     # @param definition [Lambda, Proc, UnboundMethod] the method definition
     # @return [nil]
     def define_subroutine(name, definition)
+      return if method(name).source_location.first == __FILE__
+
+      @eval_location = method(name).source_location
+
       define_singleton_method(name) do |*_args|
         callsub(name)
       end
 
-      TEAL.instance << 'b main' unless TEAL.instance.include? 'b main'
+      @teal << 'b main' unless @teal.include? 'b main'
 
       label(name) # add teal label
 
@@ -155,7 +334,9 @@ module TEALrb
       comment_content = "#{name}(#{comment_params})"
       comment(comment_content, inline: true)
 
-      new_source = generate_method_source(name, definition)
+      method_hash = self.class.method_hashes.find { _1[:name] == name.to_s }
+      new_source = generate_subroutine_source(definition, method_hash)
+
       new_source = "#{new_source}retsub"
 
       eval_tealrb(new_source, debug_context: "subroutine: #{name}")
@@ -169,23 +350,22 @@ module TEALrb
     def comment(content, inline: false)
       content = " #{content}" unless content[0] == ' '
       if inline
-        last_line = TEAL.instance.pop
-        TEAL.instance << "#{last_line} //#{content}"
+        last_line = @teal.pop
+        @teal << "#{last_line} //#{content}"
       else
-        TEAL.instance << '' unless TEAL.instance.last[%r{^//}]
-        TEAL.instance << "//#{content}"
+        @teal << "//#{content}"
       end
     end
 
     # inserts a string into TEAL source
     # @param string [String] the string to insert
     def placeholder(string)
-      TEAL.instance << string
+      @teal << string
     end
 
     # the hash of the abi description
     def abi_hash
-      self.class.abi_description.to_h
+      self.class.abi_interface.to_h
     end
 
     # transpiles the given string to TEAL
@@ -199,51 +379,157 @@ module TEALrb
     # transpiles #main and routes abi methods. To disable abi routing, set `@disable_abi_routing` to true in your
     # Contract subclass
     def compile
-      TEAL.instance << 'main:' if TEAL.instance.include? 'b main'
+      @teal << 'main:' if @teal.include? 'b main'
       route_abi_methods unless self.class.disable_abi_routing
-      eval_tealrb(rewrite(method(:main).source, method_rewriter: true), debug_context: 'main') if respond_to? :main
+      return unless respond_to? :main
+
+      @eval_location = method(:main).source_location
+
+      eval_tealrb(
+        rewrite(
+          method(:main).source,
+          method_rewriter: true
+        ),
+        debug_context: 'main'
+      )
+    end
+
+    def main
+      nil
+    end
+
+    def compiled_program
+      compile_response = Algod.new.compile(formatted_teal)
+
+      generate_source_map(formatted_teal) if compile_response.status != 200
+
+      JSON.parse(compile_response.body)['result']
     end
 
     private
 
     def route_abi_methods
-      self.class.abi_description.methods.each do |meth|
+      self.class.abi_interface.methods.each_with_index do |meth, i|
         signature = "#{meth[:name]}(#{meth[:args].map { _1[:type] }.join(',')})#{meth[:returns][:type]}"
         selector = OpenSSL::Digest.new('SHA512-256').hexdigest(signature)[..7]
 
-        IfBlock.new(AppArgs[0] == byte(selector)) do
-          callsub(meth[:name])
-          approve
-        end
+        app_args[int(0)] == byte(selector) # rubocop:disable Lint/Void
+        bz("abi_routing#{i}")
+        callsub(meth[:name])
+        approve
+        label("abi_routing#{i}")
       end
     end
 
     def generate_method_source(name, definition)
       new_source = rewrite(definition.source, method_rewriter: true)
 
-      pre_string = StringIO.new
+      pre_string = []
 
       scratch_names = []
       definition.parameters.reverse.each_with_index do |param, _i|
-        param_name = param.last
+        param_name = param.first
         scratch_name = [name, param_name].map(&:to_s).join(': ')
         scratch_names << scratch_name
 
-        pre_string.puts "@scratch.store('#{scratch_name}')"
-        pre_string.puts "#{param_name} = -> { @scratch['#{scratch_name}'] }"
+        pre_string << "@scratch.store('#{scratch_name}')"
+        pre_string << "#{param_name} = -> { @scratch['#{scratch_name}'] }"
+      end
+
+      "#{pre_string.join(';')};#{new_source}"
+    end
+
+    def generate_subroutine_source(definition, method_hash)
+      new_source = rewrite(definition.source, method_rewriter: true)
+
+      pre_string = []
+
+      scratch_names = []
+
+      txn_types = %w[txn pay keyreg acfg axfer afrz appl]
+
+      args = method_hash[:args] || []
+      arg_types = args.map { _1[:type] } || []
+      txn_params = arg_types.select { txn_types.include? _1 }.count
+      app_param_index = -1
+      asset_param_index = -1
+      account_param_index = 0
+      args_index = 0
+
+      method_hash[:on_completion].each_with_index do |oc, i|
+        this_txn.on_completion
+        int(oc)
+        equal
+        boolean_or unless i.zero?
       end
+      assert
+
+      assert(this_txn.application_id == (int(0))) if method_hash[:create]
+
+      if abi_hash['methods'].find { _1[:name] == method_hash[:name].to_s }
+        definition.parameters.each_with_index do |param, i|
+          param_name = param.last
+
+          scratch_name = "#{definition.original_name}: #{param_name} [#{arg_types[i] || 'any'}] #{
+            args[i][:desc] if args[i]}"
+          scratch_names << scratch_name
+
+          type = arg_types[i]&.downcase
+
+          if txn_types.include? type
+            @scratch[scratch_name] = group_txns[this_txn.group_index.subtract int(txn_params)]
+            txn_params -= 1
+          elsif type == 'application'
+            @scratch[scratch_name] = apps[app_param_index += 1]
+          elsif type == 'asset'
+            @scratch[scratch_name] = assets[asset_param_index += 1]
+          elsif type == 'account'
+            @scratch[scratch_name] = accounts[account_param_index += 1]
+          elsif type == 'uint64'
+            @scratch[scratch_name] = btoi(app_args[args_index += 1])
+          else
+            @scratch[scratch_name] = app_args[args_index += 1]
+          end
+
+          pre_string << "#{param_name} = -> {@scratch['#{scratch_name}'] }"
+        end
+
+      else
+        args.reverse!
+        arg_types.reverse!
+
+        definition.parameters.reverse.each_with_index do |param, i|
+          param_name = param.last
+
+          scratch_name = "#{definition.original_name}: #{param_name} [#{arg_types[i] || 'any'}] #{
+            args[i][:desc] if args[i]}"
+          scratch_names << scratch_name
+
+          type = arg_types[i]&.downcase
+
+          if txn_types.include? type
+            @scratch[scratch_name] = group_txn
+          elsif type == 'application'
+            @scratch[scratch_name] = application
+          elsif type == 'asset'
+            @scratch[scratch_name] = asset
+          elsif type == 'account'
+            @scratch[scratch_name] = account
+          else
+            @scratch.store(scratch_name)
+          end
+
+          pre_string << "#{param_name} = -> { @scratch['#{scratch_name}'] }"
+        end
 
-      post_string = StringIO.new
-      scratch_names.each do |n|
-        post_string.puts "@scratch.delete '#{n}'"
       end
 
-      "#{pre_string.string}#{new_source}#{post_string.string}"
+      "#{pre_string.join(';')};#{new_source}"
     end
 
     def rewrite_with_rewriter(string, rewriter)
       process_source = RuboCop::ProcessedSource.new(string, RUBY_VERSION[/\d\.\d/].to_f)
-      rewriter.new.rewrite(process_source)
+      rewriter.new.rewrite(process_source, self)
     end
 
     def rewrite(string, method_rewriter: false)
@@ -270,7 +556,7 @@ module TEALrb
     end
 
     def eval_tealrb(s, debug_context:)
-      pre_teal = Array.new TEAL.instance
+      pre_teal = Array.new @teal
 
       if self.class.debug
         puts "DEBUG: Evaluating the following code (#{debug_context}):"
@@ -282,32 +568,20 @@ module TEALrb
 
       if self.class.debug
         puts "DEBUG: Resulting TEAL (#{debug_context}):"
-        puts Array.new(TEAL.instance) - pre_teal
+        puts Array.new(@teal) - pre_teal
         puts ''
       end
     rescue SyntaxError, StandardError => e
       @eval_tealrb_rescue_count ||= 0
 
       eval_locations = e.backtrace.select { _1[/\(eval\)/] }
-      error_line = eval_locations[@eval_tealrb_rescue_count].split(':')[1].to_i
-
-      warn "'#{e}' when evaluating transpiled TEALrb source" if @eval_tealrb_rescue_count.zero?
-
-      warn "Backtrace location (#{@eval_tealrb_rescue_count + 1} / #{eval_locations.size}):"
-
-      @eval_tealrb_rescue_count += 1
-
-      s.lines.each_with_index do |line, i|
-        line_num = i + 1
-        if error_line == line_num
-          warn "=> #{line_num}: #{line}"
-        else
-          warn "   #{line_num}: #{line}"
-        end
+      if eval_locations[@eval_tealrb_rescue_count]
+        error_line = eval_locations[@eval_tealrb_rescue_count].split(':')[1].to_i
       end
 
-      warn ''
-      raise e
+      msg = "#{@eval_location.first}:#{error_line + @eval_location.last}"
+
+      raise e, "#{msg}: #{e}"
     end
   end
 end