generated from kommitters/.template
-
-
Notifications
You must be signed in to change notification settings - Fork 12
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Adding command_payload_json type (#121)
* Adding command_payload_json * Fix requested changes * Fix more requested changes Co-authored-by: Jhonatan Hidalgo <jhonatan-kmt@users.noreply.github.com> Co-authored-by: Santiago Botero <98826652+santiagoboterokommit@users.noreply.github.com>
- Loading branch information
3 people
committed
Nov 3, 2022
1 parent
2080ee6
commit 01a0696
Showing
6 changed files
with
826 additions
and
3 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
|
|
@@ -29,3 +29,5 @@ kadena-*.tar | |
| /priv/plts | ||
|
|
||
| /.elixir_ls | ||
|
|
||
| /.vscode | ||
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,208 @@ | ||
| defmodule Kadena.Types.CommandPayloadJSON do | ||
| @moduledoc """ | ||
| `CommandPayloadJSON` struct definition. | ||
| """ | ||
| alias Kadena.Utils.MapCase | ||
|
|
||
| alias Kadena.Types.{ | ||
| Base16String, | ||
| Cap, | ||
| CapsList, | ||
| ChainID, | ||
| CommandPayload, | ||
| ContPayload, | ||
| EnvData, | ||
| ExecPayload, | ||
| MetaData, | ||
| NetworkID, | ||
| OptionalCapsList, | ||
| PactCode, | ||
| PactDecimal, | ||
| PactInt, | ||
| PactPayload, | ||
| PactTransactionHash, | ||
| PactValue, | ||
| PactValuesList, | ||
| Proof, | ||
| Rollback, | ||
| Signer, | ||
| SignersList, | ||
| Step | ||
| } | ||
|
|
||
| @behaviour Kadena.Types.Spec | ||
|
|
||
| @type json :: String.t() | ||
| @type signers_list :: SignersList.t() | ||
| @type signers :: list(map()) | ||
| @type network_id :: NetworkID.t() | ||
| @type string_value :: String.t() | nil | ||
| @type pact_payload :: PactPayload.t() | ||
| @type proof :: Proof.t() | nil | ||
| @type data :: EnvData.t() | nil | ||
| @type meta :: MetaData.t() | ||
| @type signer :: Signer.t() | ||
| @type addr :: Base16String.t() | nil | ||
| @type scheme :: :ed25519 | nil | ||
| @type valid_scheme :: :ED25519 | nil | ||
| @type clist :: CapsList.t() | nil | ||
| @type valid_clist :: list(map()) | ||
| @type cap :: Cap.t() | ||
| @type pact_values_list :: PactValuesList.t() | ||
| @type literal :: | ||
| integer() | ||
| | boolean() | ||
| | String.t() | ||
| | PactInt.t() | ||
| | PactDecimal.t() | ||
| | PactValuesList.t() | ||
| @type value :: integer() | string_value() | boolean() | Decimal.t() | ||
| @type valid_pact_value :: list(value) | ||
| @type pact_value :: list(valid_pact_value()) | ||
| @type map_return :: map() | nil | ||
| @type valid_extract :: {:ok, string_value()} | {:ok, map_return()} | {:ok, signers()} | ||
|
|
||
| @type t :: %__MODULE__{json: json()} | ||
|
|
||
| defstruct [:json] | ||
|
|
||
| @impl true | ||
| def new(%CommandPayload{ | ||
| network_id: network_id, | ||
| payload: payload, | ||
| signers: signers, | ||
| meta: meta, | ||
| nonce: nonce | ||
| }) do | ||
| with {:ok, payload} <- extract_payload(payload), | ||
| {:ok, meta} <- extract_meta(meta), | ||
| {:ok, network_id} <- extract_network_id(network_id), | ||
| {:ok, signers} <- extract_signers_list(signers) do | ||
| request_body = | ||
| %{ | ||
| payload: payload, | ||
| meta: meta, | ||
| network_id: network_id, | ||
| nonce: nonce, | ||
| signers: signers | ||
| } | ||
| |> MapCase.to_camel!() | ||
| |> Jason.encode!() | ||
|
|
||
| %__MODULE__{json: request_body} | ||
| end | ||
| end | ||
|
|
||
| @spec extract_network_id(network_id()) :: valid_extract() | ||
| defp extract_network_id(%NetworkID{id: id}), do: {:ok, id} | ||
|
|
||
| @spec extract_payload(pact_payload()) :: valid_extract() | ||
| defp extract_payload(%PactPayload{payload: %ExecPayload{} = exec_payload}) do | ||
| %ExecPayload{code: %PactCode{code: code}, data: data} = exec_payload | ||
| payload = %{exec: %{code: code, data: extract_data(data)}} | ||
| {:ok, payload} | ||
| end | ||
|
|
||
| defp extract_payload(%PactPayload{ | ||
| payload: %ContPayload{ | ||
| data: data, | ||
| pact_id: %PactTransactionHash{hash: hash}, | ||
| proof: proof, | ||
| rollback: %Rollback{value: rollback}, | ||
| step: %Step{number: number} | ||
| } | ||
| }) do | ||
| payload = %{ | ||
| cont: %{ | ||
| data: extract_data(data), | ||
| pact_id: hash, | ||
| proof: extract_proof(proof), | ||
| roollback: rollback, | ||
| step: number | ||
| } | ||
| } | ||
|
|
||
| {:ok, payload} | ||
| end | ||
|
|
||
| @spec extract_proof(proof()) :: string_value() | ||
| defp extract_proof(nil), do: nil | ||
| defp extract_proof(%Proof{value: proof}), do: proof | ||
|
|
||
| @spec extract_data(data()) :: map_return() | ||
| defp extract_data(nil), do: nil | ||
| defp extract_data(%EnvData{data: data}), do: data | ||
|
|
||
| @spec extract_meta(meta()) :: valid_extract() | ||
| defp extract_meta(%MetaData{ | ||
| creation_time: creation_time, | ||
| ttl: ttl, | ||
| gas_limit: gas_limit, | ||
| gas_price: gas_price, | ||
| sender: sender, | ||
| chain_id: %ChainID{id: id} | ||
| }) do | ||
| meta = %{ | ||
| chain_id: id, | ||
| creation_time: creation_time, | ||
| gas_limit: gas_limit, | ||
| gas_price: gas_price, | ||
| sender: sender, | ||
| ttl: ttl | ||
| } | ||
|
|
||
| {:ok, meta} | ||
| end | ||
|
|
||
| @spec extract_signers_list(signers :: signers_list()) :: valid_extract() | ||
| defp extract_signers_list(%SignersList{signers: list}) do | ||
| signers = Enum.map(list, fn sig -> extract_signer_info(sig) end) | ||
| {:ok, signers} | ||
| end | ||
|
|
||
| @spec extract_signer_info(signer()) :: map_return() | ||
| defp extract_signer_info(%Signer{ | ||
| addr: addr, | ||
| scheme: scheme, | ||
| pub_key: %Base16String{value: pub_key}, | ||
| clist: %OptionalCapsList{clist: clist} | ||
| }) do | ||
| %{ | ||
| addr: extract_addr(addr), | ||
| scheme: extract_scheme(scheme), | ||
| pub_key: pub_key, | ||
| clist: extract_clist(clist) | ||
| } | ||
| end | ||
|
|
||
| @spec extract_addr(addr()) :: string_value() | ||
| defp extract_addr(nil), do: nil | ||
| defp extract_addr(%Base16String{value: value}), do: value | ||
|
|
||
| @spec extract_scheme(scheme()) :: valid_scheme() | ||
| defp extract_scheme(nil), do: nil | ||
| defp extract_scheme(:ed25519), do: :ED25519 | ||
|
|
||
| @spec extract_clist(clist()) :: valid_clist() | ||
| defp extract_clist(nil), do: [] | ||
|
|
||
| defp extract_clist(%CapsList{caps: caps}) do | ||
| Enum.map(caps, fn cap -> extract_cap_info(cap) end) | ||
| end | ||
|
|
||
| @spec extract_cap_info(cap()) :: map_return() | ||
| defp extract_cap_info(%Cap{name: name, args: args}) do | ||
| %{name: name, args: extract_values(args)} | ||
| end | ||
|
|
||
| @spec extract_values(pact_values_list()) :: pact_value() | ||
| defp extract_values(%PactValuesList{pact_values: pact_values}) do | ||
| Enum.map(pact_values, fn %PactValue{literal: pact_value} -> extract_value(pact_value) end) | ||
| end | ||
|
|
||
| @spec extract_value(literal()) :: valid_pact_value() | ||
| defp extract_value(%PactValuesList{} = pact_value), do: extract_values(pact_value) | ||
| defp extract_value(%PactInt{raw_value: value}), do: value | ||
| defp extract_value(%PactDecimal{raw_value: value}), do: value | ||
| defp extract_value(value), do: value | ||
| end |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,63 @@ | ||
| defmodule Kadena.Utils.MapCase do | ||
| @moduledoc """ | ||
| `Utils.MapCase` functions to convert the keys of a map to camel or snake case | ||
| """ | ||
|
|
||
| @type key :: atom() | String.t() | ||
| @type opt :: :to_camel | :to_snake | ||
| @type string_value :: String.t() | ||
| @type value :: any() | ||
| @type words :: list(string_value()) | ||
| @type valid_map :: {:ok, map()} | ||
| @type valid_format :: string_value() | map() | ||
|
|
||
| @spec to_camel(map :: map()) :: valid_map() | ||
| def to_camel(map) when is_map(map), do: {:ok, format(map, :to_camel)} | ||
|
|
||
| @spec to_camel!(map :: map()) :: map() | ||
| def to_camel!(map) when is_map(map), do: format(map, :to_camel) | ||
|
|
||
| @spec to_snake(map :: map()) :: valid_map() | ||
| def to_snake(map) when is_map(map), do: {:ok, format(map, :to_snake)} | ||
|
|
||
| @spec to_snake!(map :: map()) :: map() | ||
| def to_snake!(map) when is_map(map), do: format(map, :to_snake) | ||
|
|
||
| @spec format(map :: map(), type :: opt()) :: map() | ||
| defp format(%Decimal{} = decimal, _type), do: decimal | ||
|
|
||
| defp format(%{} = map, type) do | ||
| map | ||
| |> Enum.map(fn {k, v} -> {format_key(k, type), format_value(v, type)} end) | ||
| |> Enum.into(%{}) | ||
| end | ||
|
|
||
| defp format(value, _type), do: value | ||
|
|
||
| @spec format_key(key :: key(), type :: opt()) :: string_value() | ||
| defp format_key(key, type) when is_atom(key), | ||
| do: key |> Atom.to_string() |> format_key(type) | ||
|
|
||
| defp format_key(key, :to_camel) when is_binary(key) do | ||
| if String.contains?(key, "_") do | ||
| [first_word | rest] = String.split(key, "_") | ||
| first_word <> camelize(rest) | ||
| else | ||
| key | ||
| end | ||
| end | ||
|
|
||
| defp format_key(key, :to_snake) when is_binary(key), do: Macro.underscore(key) | ||
|
|
||
| @spec format_value(value :: value(), type :: opt()) :: valid_format() | ||
| defp format_value(value, type) when is_map(value), do: format(value, type) | ||
|
|
||
| defp format_value(value, type) when is_list(value), | ||
| do: Enum.map(value, fn map -> format(map, type) end) | ||
|
|
||
| defp format_value(value, _type), do: value | ||
|
|
||
| @spec camelize(words :: words()) :: string_value() | ||
| defp camelize([]), do: "" | ||
| defp camelize([word | rest]), do: Macro.camelize(word) <> camelize(rest) | ||
| end |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Oops, something went wrong.