CipherLabs
/
blockscout
mirror of https://github.com/blockscout/blockscout
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Import.Runner.CurrentTokenBalances update_token_holder_counts

Browse Source 
When `CurrentTokenBalance`s are directly changed

1. Determine which rows will be deleted in
   `deleted_address_current_token_balances` using same `where` as
   `on_conflict` for `address_current_token_balances`
2. Upsert rows using pre-existing `address_current_token_balances`.
3. Calculate delta of holder count using
  `deleted_address_current_token_balances` and
  `address_current_token_balances`.  If the delta is non-zero, update
   the `tokens.holder_count`.
pull/1357/head
Luke Imhoff 6 years ago
parent 4144373367
commit 4f1254b1be
6 changed files with 598 additions and 284 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 184
      apps/explorer/lib/explorer/chain/import/runner/address/current_token_balances.ex
  2. 171
      apps/explorer/lib/explorer/chain/import/runner/blocks.ex
  3. 78
      apps/explorer/lib/explorer/chain/import/runner/tokens.ex
  4. 264
      apps/explorer/test/explorer/chain/import/runner/address/current_token_balances_test.exs
  5. 77
      apps/explorer/test/explorer/chain/import/runner/blocks_test.exs
  6. 78
      apps/explorer/test/support/chain/import/runner_case.ex

184
apps/explorer/lib/explorer/chain/import/runner/address/current_token_balances.ex
Unescape View File

@ -9,7 +9,8 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalances do
alias Ecto.{Changeset, Multi, Repo}
alias Explorer.Chain.Address.CurrentTokenBalance
alias Explorer.Chain.Import
alias Explorer.Chain.{Hash, Import}
alias Explorer.Chain.Import.Runner.Tokens
@behaviour Import.Runner
@ -18,6 +19,70 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalances do
@type imported :: [CurrentTokenBalance.t()]
@spec to_holder_address_hash_set_by_token_contract_address_hash([CurrentTokenBalance.t()]) :: %{
token_contract_address_hash => MapSet.t(holder_address_hash)
}
when token_contract_address_hash: Hash.Address.t(), holder_address_hash: Hash.Address.t()
def to_holder_address_hash_set_by_token_contract_address_hash(address_current_token_balances)
when is_list(address_current_token_balances) do
address_current_token_balances
|> Stream.filter(fn %{value: value} -> not is_nil(value) && Decimal.cmp(value, 0) == :gt end)
|> Enum.reduce(%{}, fn %{token_contract_address_hash: token_contract_address_hash, address_hash: address_hash},
acc_holder_address_hash_set_by_token_contract_address_hash ->
updated_holder_address_hash_set =
acc_holder_address_hash_set_by_token_contract_address_hash
|> Map.get_lazy(token_contract_address_hash, &MapSet.new/0)
|> MapSet.put(address_hash)
Map.put(
acc_holder_address_hash_set_by_token_contract_address_hash,
token_contract_address_hash,
updated_holder_address_hash_set
)
end)
end
@spec token_holder_count_deltas(%{deleted: [current_token_balance], inserted: [current_token_balance]}) :: [
Tokens.token_holder_count_delta()
]
when current_token_balance: %{
address_hash: Hash.Address.t(),
token_contract_address_hash: Hash.Address.t(),
value: Decimal.t()
}
def token_holder_count_deltas(%{deleted: deleted, inserted: inserted}) when is_list(deleted) and is_list(inserted) do
deleted_holder_address_hash_set_by_token_contract_address_hash =
to_holder_address_hash_set_by_token_contract_address_hash(deleted)
inserted_holder_address_hash_set_by_token_contract_address_hash =
to_holder_address_hash_set_by_token_contract_address_hash(inserted)
ordered_token_contract_address_hashes =
ordered_token_contract_address_hashes([
deleted_holder_address_hash_set_by_token_contract_address_hash,
inserted_holder_address_hash_set_by_token_contract_address_hash
])
Enum.flat_map(ordered_token_contract_address_hashes, fn token_contract_address_hash ->
holder_count_delta =
holder_count_delta(%{
deleted_holder_address_hash_set_by_token_contract_address_hash:
deleted_holder_address_hash_set_by_token_contract_address_hash,
inserted_holder_address_hash_set_by_token_contract_address_hash:
inserted_holder_address_hash_set_by_token_contract_address_hash,
token_contract_address_hash: token_contract_address_hash
})
case holder_count_delta do
0 ->
[]
_ ->
[%{contract_address_hash: token_contract_address_hash, delta: holder_count_delta}]
end
end)
end
@impl Import.Runner
def ecto_schema_module, do: CurrentTokenBalance
@ -37,18 +102,109 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalances do
insert_options =
options
|> Map.get(option_key(), %{})
|> Map.take(~w(on_conflict timeout)a)
|> Map.take(~w(timeout)a)
|> Map.put_new(:timeout, @timeout)
|> Map.put(:timestamps, timestamps)
Multi.run(multi, :address_current_token_balances, fn repo, _ ->
insert(repo, changes_list, insert_options)
timeout = insert_options.timeout
# order so that row ShareLocks are grabbed in a consistent order
ordered_changes_list = Enum.sort_by(changes_list, &{&1.address_hash, &1.token_contract_address_hash})
multi
|> Multi.run(:deleted_address_current_token_balances, fn repo, _ ->
deleted_address_current_token_balances(repo, ordered_changes_list, %{timeout: timeout})
end)
|> Multi.run(:address_current_token_balances, fn repo, _ ->
insert(repo, ordered_changes_list, insert_options)
end)
|> Multi.run(:address_current_token_balances_update_token_holder_counts, fn repo,
%{
deleted_address_current_token_balances:
deleted,
address_current_token_balances:
inserted
} ->
token_holder_count_deltas = token_holder_count_deltas(%{deleted: deleted, inserted: inserted})
Tokens.update_holder_counts_with_deltas(
repo,
token_holder_count_deltas,
insert_options
)
end)
end
@impl Import.Runner
def timeout, do: @timeout
@spec deleted_address_current_token_balances(Repo.t(), [map()], %{timeout: timeout()}) ::
{:ok, [CurrentTokenBalance.t()]}
defp deleted_address_current_token_balances(_, [], _), do: {:ok, []}
defp deleted_address_current_token_balances(repo, changes_list, %{timeout: timeout})
when is_atom(repo) and is_list(changes_list) do
initial_query =
from(current_token_balance in CurrentTokenBalance,
select:
map(current_token_balance, [
:address_hash,
:token_contract_address_hash,
# to determine if a holder for `update_token_holder_counts`
:value
]),
# to maintain order of lock for `address_current_token_balances`
lock: "FOR UPDATE"
)
final_query =
Enum.reduce(changes_list, initial_query, fn %{
address_hash: address_hash,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number
},
acc_query ->
from(current_token_balance in acc_query,
or_where:
current_token_balance.address_hash == ^address_hash and
current_token_balance.token_contract_address_hash == ^token_contract_address_hash and
current_token_balance.block_number < ^block_number
)
end)
{:ok, repo.all(final_query, timeout: timeout)}
end
defp holder_count_delta(%{
deleted_holder_address_hash_set_by_token_contract_address_hash:
deleted_holder_address_hash_set_by_token_contract_address_hash,
inserted_holder_address_hash_set_by_token_contract_address_hash:
inserted_holder_address_hash_set_by_token_contract_address_hash,
token_contract_address_hash: token_contract_address_hash
}) do
case {deleted_holder_address_hash_set_by_token_contract_address_hash[token_contract_address_hash],
inserted_holder_address_hash_set_by_token_contract_address_hash[token_contract_address_hash]} do
{deleted_holder_address_hash_set, nil} ->
-1 * Enum.count(deleted_holder_address_hash_set)
{nil, inserted_holder_address_hash_set} ->
Enum.count(inserted_holder_address_hash_set)
{deleted_holder_address_hash_set, inserted_holder_address_hash_set} ->
inserted_holder_address_hash_count =
inserted_holder_address_hash_set
|> MapSet.difference(deleted_holder_address_hash_set)
|> Enum.count()
deleted_holder_address_hash_count =
deleted_holder_address_hash_set
|> MapSet.difference(inserted_holder_address_hash_set)
|> Enum.count()
inserted_holder_address_hash_count - deleted_holder_address_hash_count
end
end
@spec insert(Repo.t(), [map()], %{
optional(:on_conflict) => Import.Runner.on_conflict(),
required(:timeout) => timeout(),
@ -56,14 +212,10 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalances do
}) ::
{:ok, [CurrentTokenBalance.t()]}
| {:error, [Changeset.t()]}
def insert(repo, changes_list, %{timeout: timeout, timestamps: timestamps} = options)
when is_atom(repo) and is_list(changes_list) do
defp insert(repo, ordered_changes_list, %{timeout: timeout, timestamps: timestamps} = options)
when is_atom(repo) and is_list(ordered_changes_list) do
on_conflict = Map.get_lazy(options, :on_conflict, &default_on_conflict/0)
# order so that row ShareLocks are grabbed in a consistent order
ordered_changes_list = Enum.sort_by(changes_list, &{&1.address_hash, &1.token_contract_address_hash})
{:ok, _} =
Import.insert_changes_list(
repo,
ordered_changes_list,
@ -91,4 +243,16 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalances do
where: fragment("? < EXCLUDED.block_number", current_token_balance.block_number)
)
end
defp ordered_token_contract_address_hashes(holder_address_hash_set_by_token_contract_address_hash_list)
when is_list(holder_address_hash_set_by_token_contract_address_hash_list) do
holder_address_hash_set_by_token_contract_address_hash_list
|> Enum.reduce(MapSet.new(), fn holder_address_hash_set_by_token_contract_address_hash, acc ->
holder_address_hash_set_by_token_contract_address_hash
|> Map.keys()
|> MapSet.new()
|> MapSet.union(acc)
end)
|> Enum.sort()
end
end

171
apps/explorer/lib/explorer/chain/import/runner/blocks.ex
Unescape View File

@ -12,6 +12,8 @@ defmodule Explorer.Chain.Import.Runner.Blocks do
alias Explorer.Chain.{Address, Block, Hash, Import, InternalTransaction, Transaction}
alias Explorer.Chain.Block.Reward
alias Explorer.Chain.Import.Runner
alias Explorer.Chain.Import.Runner.Address.CurrentTokenBalances
alias Explorer.Chain.Import.Runner.Tokens
@behaviour Runner
@ -80,8 +82,13 @@ defmodule Explorer.Chain.Import.Runner.Blocks do
} ->
derive_address_current_token_balances(repo, deleted_address_current_token_balances, insert_options)
end)
|> Multi.run(:update_token_holder_counts, fn repo, changes_so_far ->
update_token_holder_counts(repo, changes_so_far, insert_options)
|> Multi.run(:blocks_update_token_holder_counts, fn repo,
%{
delete_address_current_token_balances: deleted,
derive_address_current_token_balances: inserted
} ->
deltas = CurrentTokenBalances.token_holder_count_deltas(%{deleted: deleted, inserted: inserted})
Tokens.update_holder_counts_with_deltas(repo, deltas, insert_options)
end)
|> Multi.run(:delete_rewards, fn repo, _ ->
delete_rewards(repo, changes_list, insert_options)
@ -474,166 +481,6 @@ defmodule Explorer.Chain.Import.Runner.Blocks do
end
end
# sobelow_skip ["SQL.Query"]
defp update_token_holder_counts(repo, changes_so_far, options) when is_map(changes_so_far) do
parameters = update_token_holder_counts_parameters(changes_so_far)
update_token_holder_counts(repo, parameters, options)
end
defp update_token_holder_counts(_, [], _), do: {:ok, []}
defp update_token_holder_counts(repo, parameters, %{timeout: timeout}) do
update_sql = update_token_holder_counts_sql(parameters)
with {:ok, %Postgrex.Result{columns: ["contract_address_hash", "holder_count"], command: :update, rows: rows}} <-
SQL.query(repo, update_sql, parameters, timeout: timeout) do
update_token_holder_counts =
Enum.map(rows, fn [contract_address_hash_bytes, holder_count] ->
{:ok, contract_address_hash} = Hash.Address.cast(contract_address_hash_bytes)
%{contract_address_hash: contract_address_hash, holder_count: holder_count}
end)
{:ok, update_token_holder_counts}
end
end
defp update_token_holder_counts_parameters(%{
delete_address_current_token_balances: deleted_address_current_token_balances,
derive_address_current_token_balances: derived_address_current_token_balances
}) do
previous_holder_address_hash_set_by_token_contract_address_hash =
address_current_token_balances_to_holder_address_hash_set_by_token_contract_address_hash(
deleted_address_current_token_balances
)
current_holder_address_hash_set_by_token_contract_address_hash =
address_current_token_balances_to_holder_address_hash_set_by_token_contract_address_hash(
derived_address_current_token_balances
)
ordered_token_contract_address_hashes =
ordered_token_contract_address_hashes([
previous_holder_address_hash_set_by_token_contract_address_hash,
current_holder_address_hash_set_by_token_contract_address_hash
])
Enum.flat_map(ordered_token_contract_address_hashes, fn token_contract_address_hash ->
holder_count_delta =
holder_count_delta(%{
previous_holder_address_hash_set_by_token_contract_address_hash:
previous_holder_address_hash_set_by_token_contract_address_hash,
current_holder_address_hash_set_by_token_contract_address_hash:
current_holder_address_hash_set_by_token_contract_address_hash,
token_contract_address_hash: token_contract_address_hash
})
case holder_count_delta do
0 ->
[]
_ ->
{:ok, token_contract_address_hash_bytes} = Hash.Address.dump(token_contract_address_hash)
[token_contract_address_hash_bytes, holder_count_delta]
end
end)
end
defp ordered_token_contract_address_hashes(holder_address_hash_set_by_token_contract_address_hash_list)
when is_list(holder_address_hash_set_by_token_contract_address_hash_list) do
holder_address_hash_set_by_token_contract_address_hash_list
|> Enum.reduce(MapSet.new(), fn holder_address_hash_set_by_token_contract_address_hash, acc ->
holder_address_hash_set_by_token_contract_address_hash
|> Map.keys()
|> MapSet.new()
|> MapSet.union(acc)
end)
|> Enum.sort()
end
defp holder_count_delta(%{
previous_holder_address_hash_set_by_token_contract_address_hash:
previous_holder_address_hash_set_by_token_contract_address_hash,
current_holder_address_hash_set_by_token_contract_address_hash:
current_holder_address_hash_set_by_token_contract_address_hash,
token_contract_address_hash: token_contract_address_hash
}) do
case {previous_holder_address_hash_set_by_token_contract_address_hash[token_contract_address_hash],
current_holder_address_hash_set_by_token_contract_address_hash[token_contract_address_hash]} do
{previous_holder_address_hash_set, nil} ->
-1 * Enum.count(previous_holder_address_hash_set)
{nil, current_holder_address_hash_set} ->
Enum.count(current_holder_address_hash_set)
{previous_holder_address_hash_set, current_holder_address_hash_set} ->
added_holder_address_hash_count =
current_holder_address_hash_set
|> MapSet.difference(previous_holder_address_hash_set)
|> Enum.count()
removed_holder_address_hash_count =
previous_holder_address_hash_set
|> MapSet.difference(current_holder_address_hash_set)
|> Enum.count()
added_holder_address_hash_count - removed_holder_address_hash_count
end
end
defp update_token_holder_counts_sql(parameters) when is_list(parameters) do
parameters
|> Enum.count()
|> div(2)
|> update_token_holder_counts_sql()
end
defp update_token_holder_counts_sql(row_count) when is_integer(row_count) do
parameters_sql = update_token_holder_counts_parameters_sql(row_count)
"""
UPDATE tokens
SET holder_count = holder_count + holder_counts.delta
FROM (
VALUES
#{parameters_sql}
) AS holder_counts(contract_address_hash, delta)
WHERE tokens.contract_address_hash = holder_counts.contract_address_hash AND
holder_count IS NOT NULL
RETURNING tokens.contract_address_hash, tokens.holder_count
"""
end
defp update_token_holder_counts_parameters_sql(row_count) when is_integer(row_count) do
Enum.map_join(0..(row_count - 1), ",\n ", fn i ->
contract_address_hash_parameter_number = 2 * i + 1
holder_count_number = contract_address_hash_parameter_number + 1
"($#{contract_address_hash_parameter_number}::bytea, $#{holder_count_number}::bigint)"
end)
end
defp address_current_token_balances_to_holder_address_hash_set_by_token_contract_address_hash(
address_current_token_balances
)
when is_list(address_current_token_balances) do
address_current_token_balances
|> Stream.filter(fn %{value: value} -> Decimal.cmp(value, 0) == :gt end)
|> Enum.reduce(%{}, fn %{token_contract_address_hash: token_contract_address_hash, address_hash: address_hash},
acc_holder_address_hash_set_by_token_contract_address_hash ->
updated_holder_address_hash_set =
acc_holder_address_hash_set_by_token_contract_address_hash
|> Map.get_lazy(token_contract_address_hash, &MapSet.new/0)
|> MapSet.put(address_hash)
Map.put(
acc_holder_address_hash_set_by_token_contract_address_hash,
token_contract_address_hash,
updated_holder_address_hash_set
)
end)
end
# `block_rewards` are linked to `blocks.hash`, but fetched by `blocks.number`, so when a block with the same number is
# inserted, the old block rewards need to be deleted, so that the old and new rewards aren't combined.
defp delete_rewards(repo, blocks_changes, %{timeout: timeout}) do

78
apps/explorer/lib/explorer/chain/import/runner/tokens.ex
Unescape View File

@ -7,8 +7,9 @@ defmodule Explorer.Chain.Import.Runner.Tokens do
import Ecto.Query, only: [from: 2]
alias Ecto.Adapters.SQL
alias Ecto.{Multi, Repo}
alias Explorer.Chain.{Import, Token}
alias Explorer.Chain.{Hash, Import, Token}
@behaviour Import.Runner
@ -17,6 +18,16 @@ defmodule Explorer.Chain.Import.Runner.Tokens do
@type imported :: [Token.t()]
@type token_holder_count_delta :: %{contract_address_hash: Hash.Address.t(), delta: neg_integer() | pos_integer()}
@type holder_count :: non_neg_integer()
@type token_holder_count :: %{contract_address_hash: Hash.Address.t(), count: holder_count()}
def update_holder_counts_with_deltas(repo, token_holder_count_deltas, options) do
parameters = token_holder_count_deltas_to_parameters(token_holder_count_deltas)
update_holder_counts_with_parameters(repo, parameters, options)
end
@impl Import.Runner
def ecto_schema_module, do: Token
@ -99,4 +110,69 @@ defmodule Explorer.Chain.Import.Runner.Tokens do
)
)
end
defp token_holder_count_deltas_to_parameters(token_holder_count_deltas) when is_list(token_holder_count_deltas) do
Enum.flat_map(token_holder_count_deltas, fn
%{contract_address_hash: contract_address_hash, delta: delta} ->
{:ok, contract_address_hash_bytes} = Hash.Address.dump(contract_address_hash)
[contract_address_hash_bytes, delta]
end)
end
defp update_holder_counts_with_parameters(_, [], _), do: {:ok, []}
# sobelow_skip ["SQL.Query"]
defp update_holder_counts_with_parameters(repo, parameters, %{timeout: timeout, timestamps: %{updated_at: updated_at}})
when is_list(parameters) do
update_sql = update_holder_counts_sql(parameters)
with {:ok, %Postgrex.Result{columns: ["contract_address_hash", "holder_count"], command: :update, rows: rows}} <-
SQL.query(repo, update_sql, [updated_at | parameters], timeout: timeout) do
update_token_holder_counts =
Enum.map(rows, fn [contract_address_hash_bytes, holder_count] ->
{:ok, contract_address_hash} = Hash.Address.cast(contract_address_hash_bytes)
%{contract_address_hash: contract_address_hash, holder_count: holder_count}
end)
{:ok, update_token_holder_counts}
end
end
defp update_holder_counts_sql(parameters) when is_list(parameters) do
parameters
|> Enum.count()
|> div(2)
|> update_holder_counts_sql()
end
defp update_holder_counts_sql(row_count) when is_integer(row_count) do
parameters_sql =
update_holder_counts_parameters_sql(
row_count,
# skip $1 as it is used for the common `updated_at` timestamp
2
)
"""
UPDATE tokens
SET holder_count = holder_count + holder_counts.delta,
updated_at = $1
FROM (
VALUES
#{parameters_sql}
) AS holder_counts(contract_address_hash, delta)
WHERE tokens.contract_address_hash = holder_counts.contract_address_hash AND
holder_count IS NOT NULL
RETURNING tokens.contract_address_hash, tokens.holder_count
"""
end
defp update_holder_counts_parameters_sql(row_count, start) when is_integer(row_count) do
Enum.map_join(0..(row_count - 1), ",\n ", fn i ->
contract_address_hash_parameter_number = 2 * i + start
holder_count_number = contract_address_hash_parameter_number + 1
"($#{contract_address_hash_parameter_number}::bytea, $#{holder_count_number}::bigint)"
end)
end
end

264
apps/explorer/test/explorer/chain/import/runner/address/current_token_balances_test.exs
Unescape View File

@ -1,34 +1,61 @@
defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalancesTest do
use Explorer.DataCase
import Explorer.Chain.Import.RunnerCase, only: [insert_token_balance: 1, update_holder_count!: 2]
alias Ecto.Multi
alias Explorer.Chain.{Address, Token}
alias Explorer.Chain.Address.CurrentTokenBalance
alias Explorer.Chain.Import.Runner.Address.CurrentTokenBalances
alias Explorer.Repo
describe "insert/2" do
describe "run/2" do
setup do
address = insert(:address, hash: "0xe8ddc5c7a2d2f0d7a9798459c0104fdf5e987aca")
token = insert(:token)
address = insert(:address)
token = insert(:token, holder_count: 0)
insert_options = %{
options = %{
timeout: :infinity,
timestamps: %{inserted_at: DateTime.utc_now(), updated_at: DateTime.utc_now()}
}
%{address: address, token: token, insert_options: insert_options}
%{address: address, token: token, options: options}
end
test "inserts in the current token balances", %{address: address, token: token, insert_options: insert_options} do
changes = [
test "inserts in the current token balances", %{
address: %Address{hash: address_hash},
token: %Token{contract_address_hash: token_contract_address_hash},
options: options
} do
value = Decimal.new(100)
block_number = 1
assert {:ok,
%{
address_hash: address.hash,
block_number: 1,
token_contract_address_hash: token.contract_address_hash,
value: Decimal.new(100)
address_current_token_balances: [
%Explorer.Chain.Address.CurrentTokenBalance{
address_hash: ^address_hash,
block_number: ^block_number,
token_contract_address_hash: ^token_contract_address_hash,
value: ^value
}
],
address_current_token_balances_update_token_holder_counts: [
%{
contract_address_hash: ^token_contract_address_hash,
holder_count: 1
}
]
CurrentTokenBalances.insert(Repo, changes, insert_options)
}} =
run_changes(
%{
address_hash: address_hash,
block_number: block_number,
token_contract_address_hash: token_contract_address_hash,
value: value
},
options
)
current_token_balances =
CurrentTokenBalance
@ -41,7 +68,7 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalancesTest do
test "updates when the new block number is greater", %{
address: address,
token: token,
insert_options: insert_options
options: options
} do
insert(
:address_current_token_balance,
@ -51,16 +78,15 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalancesTest do
value: 100
)
changes = [
run_changes(
%{
address_hash: address.hash,
block_number: 2,
token_contract_address_hash: token.contract_address_hash,
value: Decimal.new(200)
}
]
CurrentTokenBalances.insert(Repo, changes, insert_options)
},
options
)
current_token_balance = Repo.get_by(CurrentTokenBalance, address_hash: address.hash)
@ -69,33 +95,211 @@ defmodule Explorer.Chain.Import.Runner.Address.CurrentTokenBalancesTest do
end
test "ignores when the new block number is lesser", %{
address: address,
token: token,
insert_options: insert_options
address: %Address{hash: address_hash} = address,
token: %Token{contract_address_hash: token_contract_address_hash},
options: options
} do
insert(
:address_current_token_balance,
address: address,
block_number: 2,
token_contract_address_hash: token.contract_address_hash,
token_contract_address_hash: token_contract_address_hash,
value: 200
)
changes = [
update_holder_count!(token_contract_address_hash, 1)
assert {:ok, %{address_current_token_balances: [], address_current_token_balances_update_token_holder_counts: []}} =
run_changes(
%{
address_hash: address.hash,
address_hash: address_hash,
token_contract_address_hash: token_contract_address_hash,
block_number: 1,
token_contract_address_hash: token.contract_address_hash,
value: Decimal.new(100)
},
options
)
current_token_balance = Repo.get_by(CurrentTokenBalance, address_hash: address_hash)
assert current_token_balance.block_number == 2
assert current_token_balance.value == Decimal.new(200)
end
test "a non-holder updating to a holder increases the holder_count", %{
address: %Address{hash: address_hash} = address,
token: %Token{contract_address_hash: token_contract_address_hash},
options: options
} do
previous_block_number = 1
insert_token_balance(%{
address: address,
token_contract_address_hash: token_contract_address_hash,
block_number: previous_block_number,
value: 0
})
block_number = previous_block_number + 1
value = Decimal.new(1)
assert {:ok,
%{
address_current_token_balances: [
%Explorer.Chain.Address.CurrentTokenBalance{
address_hash: ^address_hash,
block_number: ^block_number,
token_contract_address_hash: ^token_contract_address_hash,
value: ^value
}
],
address_current_token_balances_update_token_holder_counts: [
%{
contract_address_hash: ^token_contract_address_hash,
holder_count: 1
}
]
}} =
run_changes(
%{
address_hash: address_hash,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number,
value: value
},
options
)
end
CurrentTokenBalances.insert(Repo, changes, insert_options)
test "a holder updating to a non-holder decreases the holder_count", %{
address: %Address{hash: address_hash} = address,
token: %Token{contract_address_hash: token_contract_address_hash},
options: options
} do
previous_block_number = 1
current_token_balance = Repo.get_by(CurrentTokenBalance, address_hash: address.hash)
insert_token_balance(%{
address: address,
token_contract_address_hash: token_contract_address_hash,
block_number: previous_block_number,
value: 1
})
assert current_token_balance.block_number == 2
assert current_token_balance.value == Decimal.new(200)
update_holder_count!(token_contract_address_hash, 1)
block_number = previous_block_number + 1
value = Decimal.new(0)
assert {:ok,
%{
address_current_token_balances: [
%Explorer.Chain.Address.CurrentTokenBalance{
address_hash: ^address_hash,
block_number: ^block_number,
token_contract_address_hash: ^token_contract_address_hash,
value: ^value
}
],
address_current_token_balances_update_token_holder_counts: [
%{contract_address_hash: ^token_contract_address_hash, holder_count: 0}
]
}} =
run_changes(
%{
address_hash: address_hash,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number,
value: value
},
options
)
end
test "a non-holder becoming and a holder becoming while a holder becomes a non-holder cancels out and holder_count does not change",
%{
address: %Address{hash: non_holder_becomes_holder_address_hash} = non_holder_becomes_holder_address,
token: %Token{contract_address_hash: token_contract_address_hash},
options: options
} do
previous_block_number = 1
insert_token_balance(%{
address: non_holder_becomes_holder_address,
token_contract_address_hash: token_contract_address_hash,
block_number: previous_block_number,
value: 0
})
%Address{hash: holder_becomes_non_holder_address_hash} = holder_becomes_non_holder_address = insert(:address)
insert_token_balance(%{
address: holder_becomes_non_holder_address,
token_contract_address_hash: token_contract_address_hash,
block_number: previous_block_number,
value: 1
})
update_holder_count!(token_contract_address_hash, 1)
block_number = previous_block_number + 1
non_holder_becomes_holder_value = Decimal.new(1)
holder_becomes_non_holder_value = Decimal.new(0)
assert {:ok,
%{
deleted_address_current_token_balances: [
%{
address_hash: ^non_holder_becomes_holder_address_hash,
token_contract_address_hash: ^token_contract_address_hash
},
%{
address_hash: ^holder_becomes_non_holder_address_hash,
token_contract_address_hash: ^token_contract_address_hash
}
],
address_current_token_balances: [
%{
address_hash: ^non_holder_becomes_holder_address_hash,
token_contract_address_hash: ^token_contract_address_hash,
block_number: ^block_number,
value: ^non_holder_becomes_holder_value
},
%{
address_hash: ^holder_becomes_non_holder_address_hash,
token_contract_address_hash: ^token_contract_address_hash,
block_number: ^block_number,
value: ^holder_becomes_non_holder_value
}
],
address_current_token_balances_update_token_holder_counts: []
}} =
run_changes_list(
[
%{
address_hash: non_holder_becomes_holder_address_hash,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number,
value: non_holder_becomes_holder_value
},
%{
address_hash: holder_becomes_non_holder_address_hash,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number,
value: holder_becomes_non_holder_value
}
],
options
)
end
end
defp run_changes(changes, options) when is_map(changes) do
run_changes_list([changes], options)
end
defp run_changes_list(changes_list, options) when is_list(changes_list) do
Multi.new()
|> CurrentTokenBalances.run(changes_list, options)
|> Repo.transaction()
end
end

77
apps/explorer/test/explorer/chain/import/runner/blocks_test.exs
Unescape View File

@ -3,9 +3,11 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
import Ecto.Query, only: [from: 2, select: 2, where: 2]
import Explorer.Chain.Import.RunnerCase, only: [insert_address_with_token_balances: 1, update_holder_count!: 2]
alias Ecto.Multi
alias Explorer.Chain.Import.Runner.{Blocks, Transaction}
alias Explorer.Chain.{Address, Block, Token, Transaction}
alias Explorer.Chain.{Address, Block, Transaction}
alias Explorer.Repo
describe "run/1" do
@ -122,7 +124,7 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
token_contract_address_hash: token_contract_address_hash
})
# Token must exist with non-`nil` `holder_count` for `update_token_holder_counts` to update
# Token must exist with non-`nil` `holder_count` for `blocks_update_token_holder_counts` to update
update_holder_count!(token_contract_address_hash, 1)
assert count(Address.TokenBalance) == 2
@ -153,7 +155,7 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
}
],
# no updates because it both deletes and derives a holder
update_token_holder_counts: []
blocks_update_token_holder_counts: []
}} = run_block_consensus_change(block, true, options)
assert count(Address.TokenBalance) == 1
@ -178,7 +180,7 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
token_contract_address_hash: token_contract_address_hash
})
# Token must exist with non-`nil` `holder_count` for `update_token_holder_counts` to update
# Token must exist with non-`nil` `holder_count` for `blocks_update_token_holder_counts` to update
update_holder_count!(token_contract_address_hash, 0)
block_params = params_for(:block, hash: block_hash, miner_hash: miner_hash, number: block_number, consensus: true)
@ -188,7 +190,7 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
assert {:ok,
%{
update_token_holder_counts: [
blocks_update_token_holder_counts: [
%{
contract_address_hash: ^token_contract_address_hash,
holder_count: 1
@ -210,7 +212,7 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
token_contract_address_hash: token_contract_address_hash
})
# Token must exist with non-`nil` `holder_count` for `update_token_holder_counts` to update
# Token must exist with non-`nil` `holder_count` for `blocks_update_token_holder_counts` to update
update_holder_count!(token_contract_address_hash, 1)
block_params = params_for(:block, hash: block_hash, miner_hash: miner_hash, number: block_number, consensus: true)
@ -220,7 +222,7 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
assert {:ok,
%{
update_token_holder_counts: [
blocks_update_token_holder_counts: [
%{
contract_address_hash: ^token_contract_address_hash,
holder_count: 0
@ -247,13 +249,13 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
token_contract_address_hash: token_contract_address_hash
})
# Token must exist with non-`nil` `holder_count` for `update_token_holder_counts` to update
# Token must exist with non-`nil` `holder_count` for `blocks_update_token_holder_counts` to update
update_holder_count!(token_contract_address_hash, 1)
assert {:ok,
%{
# cancels out to no change
update_token_holder_counts: []
blocks_update_token_holder_counts: []
}} = run_block_consensus_change(block, true, options)
end
end
@ -284,52 +286,6 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
})
end
defp insert_address_with_token_balances(%{
previous: %{value: previous_value},
current: %{block_number: current_block_number, value: current_value},
token_contract_address_hash: token_contract_address_hash
}) do
%Address.TokenBalance{
address_hash: address_hash,
token_contract_address_hash: ^token_contract_address_hash
} =
insert(:token_balance,
token_contract_address_hash: token_contract_address_hash,
block_number: current_block_number - 1,
value: previous_value
)
address = Repo.get(Address, address_hash)
%Address.TokenBalance{
address_hash: ^address_hash,
token_contract_address_hash: ^token_contract_address_hash,
block_number: ^current_block_number,
value: holder_current_value
} =
insert(:token_balance,
address: address,
token_contract_address_hash: token_contract_address_hash,
block_number: current_block_number,
value: current_value
)
%Address.CurrentTokenBalance{
address_hash: ^address_hash,
token_contract_address_hash: ^token_contract_address_hash,
block_number: ^current_block_number,
value: ^holder_current_value
} =
insert(:address_current_token_balance,
address: address,
token_contract_address_hash: token_contract_address_hash,
block_number: current_block_number,
value: holder_current_value
)
address
end
defp run_block_consensus_change(
%Block{hash: block_hash, miner_hash: miner_hash, number: block_number},
consensus,
@ -345,15 +301,4 @@ defmodule Explorer.Chain.Import.Runner.BlocksTest do
|> Blocks.run(changes_list, options)
|> Repo.transaction()
end
defp update_holder_count!(contract_address_hash, holder_count) do
{1, [%{holder_count: ^holder_count}]} =
Repo.update_all(
from(token in Token,
where: token.contract_address_hash == ^contract_address_hash,
select: map(token, [:holder_count])
),
set: [holder_count: holder_count]
)
end
end

78
apps/explorer/test/support/chain/import/runner_case.ex
Unescape View File

@ -0,0 +1,78 @@
defmodule Explorer.Chain.Import.RunnerCase do
import Explorer.Factory, only: [insert: 2]
import Ecto.Query, only: [from: 2]
alias Explorer.Chain.{Address, Token}
alias Explorer.Repo
def insert_address_with_token_balances(%{
previous: %{value: previous_value},
current: %{block_number: current_block_number, value: current_value},
token_contract_address_hash: token_contract_address_hash
}) do
%Address.TokenBalance{
address_hash: address_hash,
token_contract_address_hash: ^token_contract_address_hash
} =
insert(:token_balance,
token_contract_address_hash: token_contract_address_hash,
block_number: current_block_number - 1,
value: previous_value
)
address = Repo.get(Address, address_hash)
insert_token_balance(%{
address: address,
token_contract_address_hash: token_contract_address_hash,
block_number: current_block_number,
value: current_value
})
address
end
def insert_token_balance(%{
address: %Address{hash: address_hash} = address,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number,
value: value
}) do
%Address.TokenBalance{
address_hash: ^address_hash,
token_contract_address_hash: ^token_contract_address_hash,
block_number: ^block_number,
value: cast_value
} =
insert(:token_balance,
address: address,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number,
value: value
)
%Address.CurrentTokenBalance{
address_hash: ^address_hash,
token_contract_address_hash: ^token_contract_address_hash,
block_number: ^block_number,
value: ^cast_value
} =
insert(:address_current_token_balance,
address: address,
token_contract_address_hash: token_contract_address_hash,
block_number: block_number,
value: value
)
end
def update_holder_count!(contract_address_hash, holder_count) do
{1, [%{holder_count: ^holder_count}]} =
Repo.update_all(
from(token in Token,
where: token.contract_address_hash == ^contract_address_hash,
select: map(token, [:holder_count])
),
set: [holder_count: holder_count]
)
end
end
Write Preview
Loading…
Cancel
Save