tealrb 0.11.0 → 0.12.0

data/lib/tealrb/rewriters.rb

@@ -4,9 +4,11 @@ module TEALrb
   module Rewriters
     class Rewriter < Parser::TreeRewriter
       include RuboCop::AST::Traversal
+      attr_reader :contract
 
-      def rewrite(processed_source)
+      def rewrite(processed_source, contract)
         @comments = processed_source.comments
+        @contract = contract
         super(processed_source.buffer, processed_source.ast)
       end
     end
@@ -27,29 +29,6 @@ module TEALrb
       end
     end
 
-    class InternalMethodRewriter < Rewriter
-      def on_send(node)
-        teal_methods = TEALrb::Contract.class_variable_get(:@@active_contract).class.teal_methods
-
-        method_name = node.loc.selector.source.to_sym
-
-        if teal_methods.keys.include? method_name
-          param_names = teal_methods[method_name].parameters.map(&:last)
-
-          pre_string = StringIO.new
-          param_names.each_with_index do |param, i|
-            scratch_name = [method_name, param].map(&:to_s).join(': ')
-
-            pre_string.puts "@scratch.store('#{scratch_name}', #{node.children[i + 2].loc.expression.source})"
-          end
-
-          replace node.source_range, "#{pre_string.string}\n#{method_name}"
-        end
-
-        super
-      end
-    end
-
     class MethodRewriter < Rewriter
       def on_def(node)
         replace node.source_range, node.body.source
@@ -59,22 +38,11 @@ module TEALrb
       def on_block(node)
         replace node.source_range, node.body.source
       end
-
-      def on_send(node)
-        remove node.loc.selector if node.loc.selector.source == 'subroutine' || node.loc.selector.source == 'teal'
-
-        # @teal_methods[:name] = ->(*args) { ... } becomes ->(*args) { ... }
-        if ['@teal_methods', '@subroutines'].include? node.children[0]&.source
-          replace node.source_range, node.children[3].body.source
-        end
-
-        super
-      end
     end
 
     class AssignRewriter < Rewriter
       def on_lvasgn(node)
-        wrap(node.children[1].source_range, '-> { ', ' }')
+        wrap(node.children[1].source_range, '-> {', '}')
         super
       end
 
@@ -84,12 +52,12 @@ module TEALrb
       end
 
       def on_ivasgn(node)
-        wrap(node.children[1].source_range, '-> { ', ' }')
+        wrap(node.children[1].source_range, '-> {', ' }')
         super
       end
 
       def on_ivar(node)
-        insert_after(node.loc.name, '.call') unless ['@teal_methods', '@subroutines', '@scratch'].include? node.source
+        insert_after(node.loc.name, '.call')
         super
       end
 
@@ -154,34 +122,26 @@ module TEALrb
         super
       end
 
-      OPCODE_METHODS = TEALrb::Opcodes::AllOpcodes.instance_methods.freeze
+      OPCODE_METHODS = TEALrb::Opcodes::TEALOpcodes.instance_methods.freeze
+      OPCODE_INSTANCE_METHODS = TEALrb::Opcodes::BINARY_OPCODE_METHOD_MAPPING.merge(
+        TEALrb::Opcodes::UNARY_OPCODE_METHOD_MAPPING
+      )
 
       def on_send(node)
         meth_name = node.children[1]
 
         if OPCODE_METHODS.include? meth_name
-          if meth_name[/(byte|int)cblock/]
+          if %w[bytecblock intcblock pushints pushbytess switch match].include? meth_name.to_s
             @skips += node.children[2..]
           else
-            params = TEALrb::Opcodes::AllOpcodes.instance_method(meth_name).parameters
+            params = TEALrb::Opcodes::TEALOpcodes.instance_method(meth_name).parameters
             req_params = params.count { |param| param[0] == :req }
             @skips += node.children[2..(1 + req_params.size)] unless req_params.zero?
           end
-        elsif %i[comment placeholder rb].include?(meth_name) ||
-              (%i[[] []=].include?(meth_name) &&
-                  (
-                    %i[@scratch @teal_methods Gtxn
-                       AppArgs].include?(node.children[0].children.last) ||
-                    node.children[0].children.first&.children&.last == :Txna
-                  ))
-
+        elsif %i[comment placeholder rb].include?(meth_name)
           @skips << node.children[2]
-        elsif node.children.first&.children&.last == :@scratch && meth_name[/=$/]
-          nil
-        elsif %i[@scratch Gtxn].include? node.children.first&.children&.last
-          @skips << node.children.last
-        elsif %i[Accounts ApplicationArgs Assets Apps Logs].include? node.children.first&.children&.last
-          @skips << node.children.last if node.children.last.int_type?
+        elsif meth_name == :[]
+          @skips << node.children[2] if node.children[2].type == :int
         end
 
         super
@@ -222,9 +182,15 @@ module TEALrb
       def on_if(node)
         unless node.loc.respond_to? :else
           conditional = node.children[0].source
-          if_blk = node.children[1].source
 
-          replace(node.loc.expression, "if(#{conditional})\n#{if_blk}\nend")
+          if_blk = if node.keyword == 'unless'
+                     node.children[2].source
+                     conditional = "!(#{conditional})"
+                   else
+                     node.children[1].source
+                   end
+
+          replace(node.loc.expression, "if(#{conditional});#{if_blk};end")
         end
 
         super
@@ -233,17 +199,53 @@ module TEALrb
 
     class IfRewriter < Rewriter
       def on_if(node)
+        condition = node.children.first
+        block = node.children[1]
+
         case node.loc.keyword.source
-        when 'if'
-          replace(node.loc.keyword, 'IfBlock.new(')
+        when 'if', 'unless'
+          @contract.if_count += 1
+          @elsif_count ||= 0
+
+          if node.loc.keyword.source == 'unless'
+            replace(node.loc.keyword, ":if#{@contract.if_count}_condition;!")
+          else
+            replace(node.loc.keyword, ":if#{@contract.if_count}_condition;")
+          end
+          insert_before(block.source_range, ":if#{@contract.if_count}_logic;")
+
+          case node.loc.else&.source
+          when 'else'
+            insert_after(condition.source_range, "; bz :if#{@contract.if_count}_else")
+            insert_after(block.source_range, "; b :if#{@contract.if_count}_end")
+            replace(node.loc.else, ":if#{@contract.if_count}_else;")
+          when 'elsif'
+            insert_after(condition.source_range, "; bz :if#{@contract.if_count}_elsif#{@elsif_count + 1}_condition")
+            insert_after(block.source_range, "; b :if#{@contract.if_count}_end")
+            replace(node.loc.else, ":if#{@contract.if_count}_elsif#{@elsif_count + 1}_condition;")
+          else
+            insert_after(condition.source_range, "; bz :if#{@contract.if_count}_end")
+          end
+          replace(node.loc.end, ":if#{@contract.if_count}_end")
         when 'elsif'
-          replace(node.loc.keyword, 'end.elsif(')
-        end
+          @elsif_count += 1
+
+          case node.loc.else&.source
+          when 'else'
+            insert_after(condition.source_range, "; bz :if#{@contract.if_count}_else")
+            insert_after(block.source_range, "; b :if#{@contract.if_count}_end")
+            replace(node.loc.else, ":if#{@contract.if_count}_else;")
+          when 'elsif'
+            insert_after(condition.source_range, "; bz :if#{@contract.if_count}_elsif#{@elsif_count + 1}_condition")
+            insert_after(block.source_range, "; b :if#{@contract.if_count}_end")
+            replace(node.loc.else, ":if#{@contract.if_count}_elsif#{@elsif_count + 1}_condition;")
+          else
+            insert_after(condition.source_range, "; bz :if#{@contract.if_count}_end")
+          end
 
-        cond_expr = node.children.first.source_range
-        replace(cond_expr, "#{cond_expr.source} ) do")
+          insert_before(block.source_range, ":if#{@contract.if_count}_elsif#{@elsif_count}_logic;")
+        end
 
-        replace(node.loc.else, 'end.else do') if node.loc.else && node.loc.else.source == 'else'
         super
       end
     end
@@ -265,9 +267,12 @@ module TEALrb
 
       def on_while(node)
         cond_node = node.children.first
-        replace(node.loc.keyword, ":while#{while_count}\n#{cond_node.source}\nbz :end_while#{while_count}")
+        replace(
+          node.loc.keyword,
+          ":while#{while_count}_condition;#{cond_node.source};bz :while#{while_count}_end; :while#{while_count}_logic;"
+        )
         replace(node.loc.begin, '') if node.loc.begin
-        replace(node.loc.end, "b :while#{while_count}\n:end_while#{while_count}")
+        replace(node.loc.end, "b :while#{while_count}_condition;:while#{while_count}_end")
         replace(cond_node.loc.expression, '')
         super
       end

data/lib/tealrb/scratch.rb

@@ -2,14 +2,15 @@
 
 module TEALrb
   class Scratch
-    def initialize
+    def initialize(contract)
       @open_slots = (0..256).to_a
       @named_slots = {}
       @values = {}
+      @contract = contract
     end
 
     def [](key)
-      TEAL.instance << "load #{@named_slots[key]} // #{key}"
+      @contract.teal << "load #{@named_slots[key]} // #{key}"
       @values[key]
     end
 
@@ -17,9 +18,9 @@ module TEALrb
       store(key, value)
     end
 
-    def store(key, value = TEAL.instance)
+    def store(key, value = @contract.teal)
       @values[key] = value
-      TEAL.instance << "store #{@named_slots[key] ||= @open_slots.shift} // #{key}"
+      @contract.teal << "store #{@named_slots[key] ||= @open_slots.shift} // #{key}"
     end
 
     def delete(key)

data/lib/tealrb/this_txn.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module TEALrb
+  class ThisTxn < OpcodeType
+    include TxnFields
+
+    private
+
+    def txnfield_opcode(field, *_args)
+      @contract.txn field
+    end
+  end
+end

data/lib/tealrb/txn_fields.rb

@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+module TEALrb
+  module TxnFields
+    def txnfield_opcode(*args)
+      raise NotImplementedError
+    end
+
+    # @return [[]byte] 32 byte address (v1)
+    def sender(*args)
+      @contract.account txnfield_opcode('Sender', *args)
+    end
+
+    # @return [uint64] microalgos (v1)
+    def fee(*args)
+      txnfield_opcode('Fee', *args)
+    end
+
+    # @return [uint64] round number (v1)
+    def first_valid(*args)
+      txnfield_opcode('FirstValid', *args)
+    end
+
+    # @return [uint64] Causes program to fail; reserved for future use (v1)
+    def first_valid_time(*args)
+      txnfield_opcode('FirstValidTime', *args)
+    end
+
+    # @return [uint64] round number (v1)
+    def last_valid(*args)
+      txnfield_opcode('LastValid', *args)
+    end
+
+    # @return [[]byte] Any data up to 1024 bytes (v1)
+    def note(*args)
+      txnfield_opcode('Note', *args)
+    end
+
+    # @return [[]byte] 32 byte lease value (v1)
+    def lease(*args)
+      txnfield_opcode('Lease', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v1)
+    def receiver(*args)
+      @contract.account txnfield_opcode('Receiver', *args)
+    end
+
+    # @return [uint64] microalgos (v1)
+    def amount(*args)
+      txnfield_opcode('Amount', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v1)
+    def close_remainder_to(*args)
+      @contract.account txnfield_opcode('CloseRemainderTo', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v1)
+    def vote_pk(*args)
+      txnfield_opcode('VotePK', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v1)
+    def selection_pk(*args)
+      txnfield_opcode('SelectionPK', *args)
+    end
+
+    # @return [uint64] The first round that the participation key is valid. (v1)
+    def vote_first(*args)
+      txnfield_opcode('VoteFirst', *args)
+    end
+
+    # @return [uint64] The last round that the participation key is valid. (v1)
+    def vote_last(*args)
+      txnfield_opcode('VoteLast', *args)
+    end
+
+    # @return [uint64] Dilution for the 2-level participation key (v1)
+    def vote_key_dilution(*args)
+      txnfield_opcode('VoteKeyDilution', *args)
+    end
+
+    # @return [[]byte] Transaction type as bytes (v1)
+    def type(*args)
+      txnfield_opcode('Type', *args)
+    end
+
+    # @return [uint64] See table below (v1)
+    def type_enum(*args)
+      txnfield_opcode('TypeEnum', *args)
+    end
+
+    # @return [uint64] Asset ID (v1)
+    def xfer_asset(*args)
+      @contract.asset txnfield_opcode('XferAsset', *args)
+    end
+
+    # @return [uint64] value in Asset's units (v1)
+    def asset_amount(*args)
+      txnfield_opcode('AssetAmount', *args)
+    end
+
+    # @return [[]byte] 32 byte address. Causes clawback of all value of asset from AssetSender if
+    #   Sender is the Clawback address of the asset. (v1)
+    def asset_sender(*args)
+      @contract.account txnfield_opcode('AssetSender', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v1)
+    def asset_receiver(*args)
+      @contract.account txnfield_opcode('AssetReceiver', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v1)
+    def asset_close_to(*args)
+      @contract.account txnfield_opcode('AssetCloseTo', *args)
+    end
+
+    # @return [uint64] Position of this transaction within an atomic transaction group.
+    #   A stand-alone transaction is implicitly element 0 in a group of 1 (v1)
+    def group_index(*args)
+      txnfield_opcode('GroupIndex', *args)
+    end
+
+    # @return [[]byte] The computed ID for this transaction. 32 bytes. (v1)
+    def tx_id(*args)
+      txnfield_opcode('TxID', *args)
+    end
+
+    # @return [uint64] ApplicationID from ApplicationCall transaction (v2)
+    def application_id(*args)
+      @contract.app txnfield_opcode('ApplicationID', *args)
+    end
+
+    # @return [uint64] ApplicationCall transaction on completion action (v2)
+    def on_completion(*args)
+      txnfield_opcode('OnCompletion', *args)
+    end
+
+    # @return [[]byte] Arguments passed to the application in the ApplicationCall transaction (v2)
+    def application_args(*args)
+      txnfield_opcode('ApplicationArgs', *args)
+    end
+
+    # @return [uint64] Number of ApplicationArgs (v2)
+    def num_app_args(*args)
+      txnfield_opcode('NumAppArgs', *args)
+    end
+
+    # @return [[]byte] Accounts listed in the ApplicationCall transaction (v2)
+    def accounts(*args)
+      txnfield_opcode('Accounts', *args)
+    end
+
+    # @return [uint64] Number of Accounts (v2)
+    def num_accounts(*args)
+      txnfield_opcode('NumAccounts', *args)
+    end
+
+    # @return [[]byte] Approval program (v2)
+    def approval_program(*args)
+      txnfield_opcode('ApprovalProgram', *args)
+    end
+
+    # @return [[]byte] Clear state program (v2)
+    def clear_state_program(*args)
+      txnfield_opcode('ClearStateProgram', *args)
+    end
+
+    # @return [[]byte] 32 byte Sender's new AuthAddr (v2)
+    def rekey_to(*args)
+      @contract.account txnfield_opcode('RekeyTo', *args)
+    end
+
+    # @return [uint64] Asset ID in asset config transaction (v2)
+    def config_asset(*args)
+      @contract.asset txnfield_opcode('ConfigAsset', *args)
+    end
+
+    # @return [uint64] Total number of units of this asset created (v2)
+    def config_asset_total(*args)
+      txnfield_opcode('ConfigAssetTotal', *args)
+    end
+
+    # @return [uint64] Number of digits to display after the decimal place when displaying the asset (v2)
+    def config_asset_decimals(*args)
+      txnfield_opcode('ConfigAssetDecimals', *args)
+    end
+
+    # @return [uint64] Whether the asset's slots are frozen by default or not, 0 or 1 (v2)
+    def config_asset_default_frozen(*args)
+      txnfield_opcode('ConfigAssetDefaultFrozen', *args)
+    end
+
+    # @return [[]byte] Unit name of the asset (v2)
+    def config_asset_unit_name(*args)
+      txnfield_opcode('ConfigAssetUnitName', *args)
+    end
+
+    # @return [[]byte] The asset name (v2)
+    def config_asset_name(*args)
+      txnfield_opcode('ConfigAssetName', *args)
+    end
+
+    # @return [[]byte] URL (v2)
+    def config_asset_url(*args)
+      txnfield_opcode('ConfigAssetURL', *args)
+    end
+
+    # @return [[]byte] 32 byte commitment to some unspecified asset metadata (v2)
+    def config_asset_metadata_hash(*args)
+      txnfield_opcode('ConfigAssetMetadataHash', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v2)
+    def config_asset_manager(*args)
+      @contract.account txnfield_opcode('ConfigAssetManager', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v2)
+    def config_asset_reserve(*args)
+      @contract.account txnfield_opcode('ConfigAssetReserve', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v2)
+    def config_asset_freeze(*args)
+      @contract.account txnfield_opcode('ConfigAssetFreeze', *args)
+    end
+
+    # @return [[]byte] 32 byte address (v2)
+    def config_asset_clawback(*args)
+      @contract.account txnfield_opcode('ConfigAssetClawback', *args)
+    end
+
+    # @return [uint64] Asset ID being frozen or un-frozen (v2)
+    def freeze_asset(*args)
+      @contract.asset txnfield_opcode('FreezeAsset', *args)
+    end
+
+    # @return [[]byte] 32 byte address of the account whose asset slot is being frozen or un-frozen (v2)
+    def freeze_asset_account(*args)
+      @contract.account txnfield_opcode('FreezeAssetAccount', *args)
+    end
+
+    # @return [uint64] The new frozen value, 0 or 1 (v2)
+    def freeze_asset_frozen(*args)
+      txnfield_opcode('FreezeAssetFrozen', *args)
+    end
+
+    # @return [uint64] Foreign Assets listed in the ApplicationCall transaction (v3)
+    def assets(*args)
+      txnfield_opcode('Assets', *args)
+    end
+
+    # @return [uint64] Number of Assets (v3)
+    def num_assets(*args)
+      txnfield_opcode('NumAssets', *args)
+    end
+
+    # @return [uint64] Foreign Apps listed in the ApplicationCall transaction (v3)
+    def applications(*args)
+      txnfield_opcode('Applications', *args)
+    end
+
+    # @return [uint64] Number of Applications (v3)
+    def num_applications(*args)
+      txnfield_opcode('NumApplications', *args)
+    end
+
+    # @return [uint64] Number of global state integers in ApplicationCall (v3)
+    def global_num_uint(*args)
+      txnfield_opcode('GlobalNumUint', *args)
+    end
+
+    # @return [uint64] Number of global state byteslices in ApplicationCall (v3)
+    def global_num_byte_slice(*args)
+      txnfield_opcode('GlobalNumByteSlice', *args)
+    end
+
+    # @return [uint64] Number of local state integers in ApplicationCall (v3)
+    def local_num_uint(*args)
+      txnfield_opcode('LocalNumUint', *args)
+    end
+
+    # @return [uint64] Number of local state byteslices in ApplicationCall (v3)
+    def local_num_byte_slice(*args)
+      txnfield_opcode('LocalNumByteSlice', *args)
+    end
+
+    # @return [uint64] Number of additional pages for each of the application's approval and clear state programs.
+    #   An ExtraProgramPages of 1 means 2048 more total bytes, or 1024 for each program. (v4)
+    def extra_program_pages(*args)
+      txnfield_opcode('ExtraProgramPages', *args)
+    end
+
+    # @return [uint64] Marks an account nonparticipating for rewards (v5)
+    def nonparticipation(*args)
+      txnfield_opcode('Nonparticipation', *args)
+    end
+
+    # @return [[]byte] Log messages emitted by an application call (only with itxn in v5). Application mode only (v5)
+    def logs(*args)
+      txnfield_opcode('Logs', *args)
+    end
+
+    # @return [uint64] Number of Logs (only with itxn in v5). Application mode only (v5)
+    def num_logs(*args)
+      txnfield_opcode('NumLogs', *args)
+    end
+
+    # @return [uint64] Asset ID allocated by the creation of an ASA (only with itxn in v5). Application mode only (v5)
+    def created_asset_id(*args)
+      @contract.asset txnfield_opcode('CreatedAssetID', *args)
+    end
+
+    # @return [uint64] ApplicationID allocated by the creation of an application (only with itxn in v5).
+    #   Application mode only (v5)
+    def created_application_id(*args)
+      @contract.app txnfield_opcode('CreatedApplicationID', *args)
+    end
+
+    # @return [[]byte] The last message emitted. Empty bytes if none were emitted. Application mode only (v6)
+    def last_log(*args)
+      txnfield_opcode('LastLog', *args)
+    end
+
+    # @return [[]byte] 64 byte state proof public key commitment (v6)
+    def state_proof_pk(*args)
+      txnfield_opcode('StateProofPK', *args)
+    end
+  end
+end

data/lib/tealrb.rb

@@ -3,32 +3,39 @@
 require 'method_source'
 require 'rubocop'
 require 'yard'
+require 'faraday'
+require 'source_map'
 
 require_relative 'tealrb/constants'
 require_relative 'tealrb/abi'
 require_relative 'tealrb/opcodes'
-require_relative 'tealrb/opcode_modules'
-require_relative 'tealrb/rewriters'
-require_relative 'tealrb/if_block'
+require_relative 'tealrb/maybe_ops'
+require_relative 'tealrb/byte_opcodes'
+require_relative 'tealrb/txn_fields'
+require_relative 'tealrb/opcode_type'
+require_relative 'tealrb/account'
+require_relative 'tealrb/this_txn'
+require_relative 'tealrb/box'
+require_relative 'tealrb/inner_txn'
+require_relative 'tealrb/group_txn'
+require_relative 'tealrb/global'
+require_relative 'tealrb/app'
+require_relative 'tealrb/asset'
+require_relative 'tealrb/logs'
+require_relative 'tealrb/app_args'
+require_relative 'tealrb/local'
+require_relative 'tealrb/enums'
 require_relative 'tealrb/scratch'
+require_relative 'tealrb/algod'
+require_relative 'tealrb/rewriters'
 require_relative 'tealrb/contract'
 require_relative 'tealrb/cmd_line/teal2tealrb'
 
 module TEALrb
   class TEAL < Array
-    class << self
-      attr_writer :instance
-
-      def instance
-        raise 'TEALrb does not support multi-threading' if Thread.current != Thread.main
-
-        @instance
-      end
-    end
-
-    def initialize(teal_array)
-      self.class.instance = self
-      super
+    def initialize(teal_array, contract)
+      @contract = contract
+      super(teal_array)
     end
 
     def teal
@@ -39,19 +46,41 @@ module TEALrb
       self << '&&'
     end
 
+    def <<(value)
+      return super unless @contract.class.src_map
+      return super if caller.join['src_map']
+      return super unless @contract.eval_location
+
+      eval_location = caller.reverse.find { _1[/^\(eval/] }&.split(':')
+      return super unless eval_location
+
+      eval_line = eval_location[1].to_i
+      src_map(@contract.eval_location.first, @contract.eval_location.last + eval_line)
+      super
+    end
+
+    def src_map(file, line_number)
+      ln = "// src_map:#{File.basename(file)}:#{line_number}"
+      return if ln == @last_src_map
+
+      @last_src_map = ln
+
+      self << ln
+    end
+
     def boolean_or(_other)
       self << '||'
     end
 
     TEALrb::Opcodes::BINARY_OPCODE_METHOD_MAPPING.each do |meth, opcode|
       define_method(meth) do |other|
-        TEALrb::Opcodes::ExtendedOpcodes.send(opcode, self, other)
+        @contract.send(opcode, self, other)
       end
     end
 
     TEALrb::Opcodes::UNARY_OPCODE_METHOD_MAPPING.each do |meth, opcode|
       define_method(meth) do
-        TEALrb::Opcodes::ExtendedOpcodes.send(opcode, self)
+        @contract.send(opcode, self)
       end
     end
   end