improve local transfer APIs

Author: vans163

ex/config/runtime.exs

@@ -36,10 +36,10 @@ end
 
 path = Path.join([work_folder, "sk"])
 if !File.exists?(path) do
-    IO.puts "No trainer sk (BLS12-381) in #{path} as base58"
+    #IO.puts "No trainer sk (BLS12-381) in #{path} as base58"
     sk = :crypto.strong_rand_bytes(64)
-    pk = BlsEx.get_public_key!(sk)
-    IO.puts "generated random sk, your pk is #{Base58.encode(pk)}"
+    #pk = BlsEx.get_public_key!(sk)
+    #IO.puts "generated random sk, your pk is #{Base58.encode(pk)}"
     :ok = File.write!(path, Base58.encode(sk))
 end
 sk = File.read!(path) |> String.trim() |> Base58.decode()
@@ -48,7 +48,7 @@ pop = BlsEx.sign!(sk, pk, BLS12AggSig.dst_pop())
 
 config :ama, :trainer_pk_b58, pk |> Base58.encode()
 config :ama, :trainer_pk, pk
-config :ama, :trainer_sk, sk
+config :ama, :trainer_sk, System.get_env("SEED64") || sk
 config :ama, :trainer_pop, pop
 
 config :ama, :archival_node, System.get_env("ARCHIVALNODE") in ["true", "y", "yes"]

ex/lib/api/api_chain.ex

@@ -5,13 +5,23 @@ defmodule API.Chain do
         %{error: :ok, entry: entry}
     end
 
-    def entry(entry_hash) do
+    def entry(entry_hash, filter_on_function \\ nil) do
         entry_hash = if byte_size(entry_hash) != 32, do: Base58.decode(entry_hash), else: entry_hash
         entry = Fabric.entry_by_hash(entry_hash)
         if !entry do
             %{error: :not_found}
         else
+            next_entry = API.Chain.by_height(entry.header_unpacked.height+1).entries
+            |> Enum.find(& &1.header_unpacked.prev_hash == Base58.encode(entry.hash) && &1[:consensus][:finality_reached])
             entry = format_entry_for_client(entry)
+            entry = if !next_entry do entry else
+              put_in(entry, [:next_entry_hash_finality_reached], next_entry.hash)
+            end
+            entry = if !filter_on_function do entry else
+              txs_filtered = API.TX.get_by_entry(entry.hash)
+              |> Enum.filter(& List.first(&1.tx.actions)[:function] == filter_on_function)
+              put_in(entry, [:txs_filtered], txs_filtered)
+            end
             %{error: :ok, entry: entry}
         end
     end
@@ -116,6 +126,7 @@ defmodule API.Chain do
         if !score do entry else
             entry = put_in(entry, [:consensus], %{})
             entry = put_in(entry, [:consensus, :score], Float.round(score, 3))
+            entry = put_in(entry, [:consensus, :finality_reached], Float.round(score, 3) >= 0.67)
             entry = put_in(entry, [:consensus, :mut_hash], Base58.encode(mut_hash))
         end
     end

ex/lib/api/api_wallet.ex

@@ -30,6 +30,7 @@ defmodule API.Wallet do
     def transfer(from_sk, to, amount, symbol, broadcast \\ true) do
         from_sk = if byte_size(from_sk) != 64, do: Base58.decode(from_sk), else: from_sk
         to = if byte_size(to) != 48, do: Base58.decode(to), else: to
+        if !BlsEx.validate_public_key(to) and to != @burn_address, do: throw(%{error: :invalid_receiver_pk})
         amount = if is_float(amount) do trunc(amount * 1_000_000_000) else amount end
         amount = if is_integer(amount) do :erlang.integer_to_binary(amount) else amount end
         tx_packed = TX.build(from_sk, "Coin", "transfer", [to, amount, symbol])

ex/lib/api/rpc_api.ex

@@ -8,20 +8,35 @@ defmodule RPC.API do
 
   defmodule Wallet do
     def transfer(seed64, receiver, amount_float, symbol \\ "AMA") do
-      tx_packed = API.Wallet.transfer(seed64, receiver, amount_float, symbol, false)
-      RPC.API.get("/api/tx/submit/#{Base58.encode(tx_packed)}")
+      if !BlsEx.validate_public_key(receiver) and receiver != @burn_address do
+        IO.inspect {"sending #{amount_float} AMA to invalid public key", receiver}
+        %{error: :invalid_public_key, pk: receiver}
+      else
+        tx_packed = API.Wallet.transfer(seed64, receiver, amount_float, symbol, false)
+        RPC.API.get("/api/tx/submit/#{Base58.encode(tx_packed)}")
+      end
     end
 
     def transfer_bulk(seed64, receiver_amount_list) do
       Enum.map(receiver_amount_list, fn
         {receiver, amount_float} ->
-          IO.inspect {"sending #{amount_float} AMA to ", receiver}
-          tx_packed = API.Wallet.transfer(seed64, receiver, amount_float, "AMA", false)
-          RPC.API.get("/api/tx/submit/#{Base58.encode(tx_packed)}")
+          if !BlsEx.validate_public_key(receiver) and receiver != @burn_address do
+            IO.inspect {"sending #{amount_float} AMA to invalid public key", receiver}
+            %{error: :invalid_public_key, pk: receiver}
+          else
+            IO.inspect {"sending #{amount_float} AMA to ", receiver}
+            tx_packed = API.Wallet.transfer(seed64, receiver, amount_float, "AMA", false)
+            RPC.API.get("/api/tx/submit/#{Base58.encode(tx_packed)}")
+          end
         {receiver, amount_float, symbol} ->
-          IO.inspect {"sending #{amount_float} #{symbol} to ", receiver}
-          tx_packed = API.Wallet.transfer(seed64, receiver, amount_float, symbol, false)
-          RPC.API.get("/api/tx/submit/#{Base58.encode(tx_packed)}")
+          if !BlsEx.validate_public_key(receiver) and receiver != @burn_address do
+            IO.inspect {"sending #{amount_float} AMA to invalid public key", receiver}
+            %{error: :invalid_public_key, pk: receiver}
+          else
+            IO.inspect {"sending #{amount_float} #{symbol} to ", receiver}
+            tx_packed = API.Wallet.transfer(seed64, receiver, amount_float, symbol, false)
+            RPC.API.get("/api/tx/submit/#{Base58.encode(tx_packed)}")
+          end
       end)
     end
 

ex/lib/ex_bakeware.ex

@@ -6,12 +6,15 @@ defmodule Ama.Bakeware do
     def main(args) do
         arg0 = List.first(args)
         cond do
-          arg0 == "buildtx" ->
-            Process.sleep(500)
-            IO.puts ""
+          arg0 == "generate_wallet" ->
+            seed64 = :crypto.strong_rand_bytes(64)
+            pk = BlsEx.get_public_key!(seed64)
+            IO.puts "#{Base58.encode(pk)} #{Base58.encode(seed64)}"
+            :erlang.halt()
 
+          arg0 == "buildtx" ->
             ["buildtx", contract, func, args | rest] = args
-            contract = if Base58.likely(contract) do Base58.decode(contract) else contract end
+            contract = if byte_size(contract) > 48 do Base58.decode(contract) else contract end
             sk = Application.fetch_env!(:ama, :trainer_sk)
             {args, []} = Code.eval_string(args)
             [attach_symbol, attach_amount] = if length(rest) != 2 do [nil,nil] else
@@ -21,10 +24,23 @@ defmodule Ama.Bakeware do
             IO.puts Base58.encode(packed_tx)
             :erlang.halt()
 
-          arg0 == "deploytx" ->
-            Process.sleep(500)
-            IO.puts ""
+          arg0 == "build_and_broadcasttx" ->
+            ["build_and_broadcasttx", contract, func, args | rest] = args
+            contract = if byte_size(contract) > 48 do Base58.decode(contract) else contract end
+            sk = Application.fetch_env!(:ama, :trainer_sk)
+            {args, []} = Code.eval_string(args)
+            [attach_symbol, attach_amount] = if length(rest) != 2 do [nil,nil] else
+              [attach_symbol, attach_amount] = rest
+            end
+            packed_tx = TX.build(sk, contract, func, args, nil, attach_symbol, attach_amount)
+            result = RPC.API.get("/api/tx/submit/#{Base58.encode(packed_tx)}")
+            #IO.puts Base58.encode(packed_tx)
+            if result[:error] == "ok" do
+              IO.puts(result.hash)
+            end
+            :erlang.halt()
 
+          arg0 == "deploytx" ->
             ["deploytx", wasmpath] = args
             sk = Application.fetch_env!(:ama, :trainer_sk)
             wasmbytes = File.read!(wasmpath)
@@ -38,9 +54,6 @@ defmodule Ama.Bakeware do
             :erlang.halt()
 
           arg0 == "getpk" ->
-            Process.sleep(500)
-            IO.puts ""
-
             ["getpk", path] = args
             sk = File.read!(path) |> String.trim()
             pk = BlsEx.get_public_key!(Base58.decode(sk))

ex/lib/http/multiserver.ex

@@ -101,6 +101,14 @@ defmodule Ama.MultiServer do
             r.method == "GET" and String.starts_with?(r.path, "/api/chain/tip") ->
                 result = API.Chain.entry_tip()
                 quick_reply(state, result)
+
+            r.method == "GET" and String.starts_with?(r.path, "/api/chain/hash/") ->
+                hash = String.replace(r.path, "/api/chain/hash/", "")
+                query = r.query && Photon.HTTP.parse_query(r.query)
+                filter_on_function = query[:filter_on_function]
+                result = API.Chain.entry(hash, filter_on_function)
+                quick_reply(state, result)
+
             r.method == "GET" and String.starts_with?(r.path, "/api/chain/height/") ->
                 height = String.replace(r.path, "/api/chain/height/", "")
                 |> :erlang.binary_to_integer()