hive-nectar 0.0.10__py3-none-any.whl → 0.1.0__py3-none-any.whl

nectar/snapshot.py

@@ -2,12 +2,13 @@
 import json
 import logging
 import re
+import warnings
 from bisect import bisect_left
 from datetime import date, datetime, time, timedelta, timezone
 
 from nectar.account import Account
 from nectar.amount import Amount
-from nectar.constants import STEEM_100_PERCENT, STEEM_VOTE_REGENERATION_SECONDS
+from nectar.constants import HIVE_100_PERCENT, HIVE_VOTE_REGENERATION_SECONDS
 from nectar.instance import shared_blockchain_instance
 from nectar.utils import (
     addTzInfo,
@@ -24,30 +25,53 @@ class AccountSnapshot(list):
     """This class allows to easily access Account history
 
     :param str account_name: Name of the account
-    :param Steem blockchain_instance: Steem
-           instance
+    :param Hive blockchain_instance: Hive instance
     """
 
-    def __init__(self, account, account_history=[], blockchain_instance=None, **kwargs):
-        if blockchain_instance is None:
-            if kwargs.get("steem_instance"):
-                blockchain_instance = kwargs["steem_instance"]
-            elif kwargs.get("hive_instance"):
-                blockchain_instance = kwargs["hive_instance"]
+    def __init__(self, account, account_history=None, blockchain_instance=None, **kwargs):
+        super(AccountSnapshot, self).__init__(account_history or [])
+        # Warn about any unused kwargs to maintain backward compatibility
+        """
+        Initialize an AccountSnapshot for the given account.
+
+        Creates an Account object for the target account (using the provided blockchain instance or the shared instance), resets internal snapshot state, and populates the snapshot list with any provided account_history. Any unexpected keyword arguments are accepted but ignored; a DeprecationWarning is emitted for each.
+
+        Parameters:
+            account (str or Account): Account identifier or existing Account object to build the snapshot for.
+            account_history (iterable, optional): Pre-fetched sequence of account operations to initialize the snapshot with. Defaults to an empty list.
+
+        Notes:
+            - blockchain_instance is accepted but not documented here as a service-like parameter; if provided it overrides the shared blockchain instance used to construct the Account.
+            - This initializer mutates internal state (calls reset) and appends account_history into the snapshot's underlying list.
+        """
+        if kwargs:
+            for key in kwargs:
+                warnings.warn(
+                    f"Unexpected keyword argument '{key}' passed to AccountSnapshot.__init__. "
+                    "This may be a deprecated parameter and will be ignored.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
         self.blockchain = blockchain_instance or shared_blockchain_instance()
         self.account = Account(account, blockchain_instance=self.blockchain)
         self.reset()
         super(AccountSnapshot, self).__init__(account_history)
 
     def reset(self):
-        """Resets the arrays not the stored account history"""
+        """
+        Reset internal time-series and aggregation arrays while preserving the stored account history.
+
+        Reinitializes per-timestamp state used to build derived metrics (vesting, Hive/HBD balances, delegations,
+        operation statistics, reward and vote timelines, reputation and voting-power arrays). Does not modify
+        the list contents (the stored raw account history).
+        """
         self.own_vests = [
             Amount(0, self.blockchain.vest_token_symbol, blockchain_instance=self.blockchain)
         ]
-        self.own_steem = [
+        self.own_hive = [
             Amount(0, self.blockchain.token_symbol, blockchain_instance=self.blockchain)
         ]
-        self.own_sbd = [
+        self.own_hbd = [
             Amount(0, self.blockchain.backed_token_symbol, blockchain_instance=self.blockchain)
         ]
         self.delegated_vests_in = [{}]
@@ -59,8 +83,8 @@ class AccountSnapshot(list):
         self.reward_timestamps = []
         self.author_rewards = []
         self.curation_rewards = []
-        self.curation_per_1000_SP_timestamp = []
-        self.curation_per_1000_SP = []
+        self.curation_per_1000_HP_timestamp = []
+        self.curation_per_1000_HP = []
         self.out_vote_timestamp = []
         self.out_vote_weight = []
         self.in_vote_timestamp = []
@@ -136,7 +160,22 @@ class AccountSnapshot(list):
                 yield op
 
     def get_data(self, timestamp=None, index=0):
-        """Returns snapshot for given timestamp"""
+        """
+        Return a dictionary snapshot of the account state at or immediately before the given timestamp.
+
+        If timestamp is None the current UTC time is used. The timestamp is normalized to a timezone-aware UTC value. The method finds the most recent stored tick whose timestamp is <= the requested time and returns a dict with the corresponding state:
+        - "timestamp": stored timestamp used
+        - "vests": own vesting shares at that tick
+        - "delegated_vests_in": mapping of incoming delegations at that tick
+        - "delegated_vests_out": mapping of outgoing delegations at that tick
+        - "sp_own": Hive Power equivalent of own vests at that tick
+        - "sp_eff": effective Hive Power (own + delegated_in - delegated_out) at that tick
+        - "hive": liquid HIVE balance at that tick
+        - "hbd": liquid HBD balance at that tick
+        - "index": index into the internal arrays for that tick
+
+        Returns an empty dict if the requested timestamp is earlier than the earliest stored timestamp.
+        """
         if timestamp is None:
             timestamp = datetime.now(timezone.utc)
         timestamp = addTzInfo(timestamp)
@@ -150,20 +189,13 @@ class AccountSnapshot(list):
         own = self.own_vests[index]
         din = self.delegated_vests_in[index]
         dout = self.delegated_vests_out[index]
-        steem = self.own_steem[index]
-        sbd = self.own_sbd[index]
+        hive = self.own_hive[index]
+        hbd = self.own_hbd[index]
         sum_in = sum([din[key].amount for key in din])
         sum_out = sum([dout[key].amount for key in dout])
-        from nectar import Steem
-
-        if isinstance(self.blockchain, Steem):
-            sp_in = self.blockchain.vests_to_sp(sum_in, timestamp=ts)
-            sp_out = self.blockchain.vests_to_sp(sum_out, timestamp=ts)
-            sp_own = self.blockchain.vests_to_sp(own, timestamp=ts)
-        else:
-            sp_in = self.blockchain.vests_to_hp(sum_in, timestamp=ts)
-            sp_out = self.blockchain.vests_to_hp(sum_out, timestamp=ts)
-            sp_own = self.blockchain.vests_to_hp(own, timestamp=ts)
+        sp_in = self.blockchain.vests_to_hp(sum_in, timestamp=ts)
+        sp_out = self.blockchain.vests_to_hp(sum_out, timestamp=ts)
+        sp_own = self.blockchain.vests_to_hp(own, timestamp=ts)
         sp_eff = sp_own + sp_in - sp_out
         return {
             "timestamp": ts,
@@ -172,40 +204,76 @@ class AccountSnapshot(list):
             "delegated_vests_out": dout,
             "sp_own": sp_own,
             "sp_eff": sp_eff,
-            "steem": steem,
-            "sbd": sbd,
+            "hive": hive,
+            "hbd": hbd,
             "index": index,
         }
 
     def get_account_history(self, start=None, stop=None, use_block_num=True):
-        """Uses account history to fetch all related ops
-
-        :param start: start number/date of transactions to
-            return (*optional*)
-        :type start: int, datetime
-        :param stop: stop number/date of transactions to
-            return (*optional*)
-        :type stop: int, datetime
-        :param bool use_block_num: if true, start and stop are block numbers,
-            otherwise virtual OP count numbers.
+        """
+        Populate the snapshot with the account's history between start and stop.
 
+        Fetches operations from the underlying Account.history iterator and replaces the snapshot's contents with those operations. If start/stop are provided they may be block numbers or datetimes; set use_block_num=False to interpret them as virtual operation indices/timestamps instead of block numbers.
         """
         super(AccountSnapshot, self).__init__(
             [h for h in self.account.history(start=start, stop=stop, use_block_num=use_block_num)]
         )
 
-    def update_rewards(self, timestamp, curation_reward, author_vests, author_steem, author_sbd):
+    def update_rewards(self, timestamp, curation_reward, author_vests, author_hive, author_hbd):
+        """
+        Record a reward event at a given timestamp.
+
+        Appends the reward timestamp, the curation portion, and the author's reward components (vests, hive, hbd)
+        to the snapshot's internal reward arrays so they can be used by later aggregation and analysis.
+
+        Parameters:
+            timestamp (datetime or int): Event time (timezone-aware datetime or block/time integer) for the reward.
+            curation_reward (Amount or number): Curation reward amount (in vests or numeric representation used by the codebase).
+            author_vests (Amount or number): Author reward in vesting shares.
+            author_hive (Amount or number): Author reward in liquid HIVE.
+            author_hbd (Amount or number): Author reward in HBD.
+
+        Returns:
+            None
+        """
         self.reward_timestamps.append(timestamp)
         self.curation_rewards.append(curation_reward)
-        self.author_rewards.append(
-            {"vests": author_vests, "steem": author_steem, "sbd": author_sbd}
-        )
+        self.author_rewards.append({"vests": author_vests, "hive": author_hive, "hbd": author_hbd})
 
     def update_out_vote(self, timestamp, weight):
+        """
+        Record an outbound vote event.
+
+        Appends the vote timestamp and weight to the snapshot's outbound-vote arrays for later voting-power and history calculations.
+
+        Parameters:
+            timestamp (datetime | int): Time of the vote (timezone-aware datetime or block timestamp).
+            weight (int): Vote weight as an integer (e.g., range -10000..10000).
+        """
         self.out_vote_timestamp.append(timestamp)
         self.out_vote_weight.append(weight)
 
     def update_in_vote(self, timestamp, weight, op):
+        """
+        Record an incoming vote event by parsing a Vote operation and appending its data to the snapshot's in-vote arrays.
+
+        Parses the provided operation into a Vote, refreshes it, and on success appends:
+        - timestamp to in_vote_timestamp
+        - weight to in_vote_weight
+        - the voter's reputation to in_vote_rep (as int)
+        - the vote's rshares to in_vote_rshares (as int)
+
+        Parameters:
+            timestamp: datetime
+                Time of the vote event (should be timezone-aware).
+            weight: int
+                Vote weight as provided by the operation.
+            op:
+                Raw operation data used to construct the Vote.
+
+        Notes:
+            If the operation cannot be parsed into a valid Vote, the function prints an error message and returns without modifying the snapshot.
+        """
         v = Vote(op)
         try:
             v.refresh()
@@ -217,31 +285,38 @@ class AccountSnapshot(list):
             print("Could not find: %s" % v)
             return
 
-    def update(self, timestamp, own, delegated_in=None, delegated_out=None, steem=0, sbd=0):
-        """Updates the internal state arrays
-
-        :param datetime timestamp: datetime of the update
-        :param own: vests
-        :type own: amount.Amount, float
-        :param dict delegated_in: Incoming delegation
-        :param dict delegated_out: Outgoing delegation
-        :param steem: steem
-        :type steem: amount.Amount, float
-        :param sbd: sbd
-        :type sbd: amount.Amount, float
-
+    def update(self, timestamp, own, delegated_in=None, delegated_out=None, hive=0, hbd=0):
+        """
+        Update internal time-series state with a new account event.
+
+        Appends two timeline entries: a one-second "pre-tick" preserving the previous state at timestamp - 1s, then a tick at timestamp with updated balances and delegation maps. This updates the snapshot's arrays for timestamps, own vests, liquid HIVE/HBD balances, and incoming/outgoing vesting delegations.
+
+        Parameters:
+            timestamp (datetime): Event time (timezone-aware). A "pre-tick" is created at timestamp - 1s.
+            own (Amount or float): Change in the account's own vesting shares (vests) to apply at the tick.
+            delegated_in (dict or None): Incoming delegation change of form {"account": name, "amount": vests} or None.
+                If amount == 0 the delegation entry for that account is removed.
+            delegated_out (dict or None): Outgoing delegation change. Typical forms:
+                - {"account": name, "amount": vests} to add/update a non-zero outgoing delegation.
+                - {"account": None, "amount": vests} indicates a return_vesting_delegation; the matching outgoing entry with the same amount is removed.
+                If omitted or empty, outgoing delegations are unchanged.
+            hive (Amount or float): Change in liquid HIVE to apply at the tick.
+            hbd (Amount or float): Change in liquid HBD to apply at the tick.
+
+        Returns:
+            None
         """
         self.timestamps.append(timestamp - timedelta(seconds=1))
         self.own_vests.append(self.own_vests[-1])
-        self.own_steem.append(self.own_steem[-1])
-        self.own_sbd.append(self.own_sbd[-1])
+        self.own_hive.append(self.own_hive[-1])
+        self.own_hbd.append(self.own_hbd[-1])
         self.delegated_vests_in.append(self.delegated_vests_in[-1])
         self.delegated_vests_out.append(self.delegated_vests_out[-1])
 
         self.timestamps.append(timestamp)
         self.own_vests.append(self.own_vests[-1] + own)
-        self.own_steem.append(self.own_steem[-1] + steem)
-        self.own_sbd.append(self.own_sbd[-1] + sbd)
+        self.own_hive.append(self.own_hive[-1] + hive)
+        self.own_hbd.append(self.own_hbd[-1] + hbd)
 
         new_deleg = dict(self.delegated_vests_in[-1])
         if delegated_in is not None and delegated_in:
@@ -309,33 +384,40 @@ class AccountSnapshot(list):
     def parse_op(
         self, op, only_ops=[], enable_rewards=False, enable_out_votes=False, enable_in_votes=False
     ):
-        """Parse account history operation"""
+        """
+        Parse a single account-history operation and update the snapshot's internal state.
+
+        Parses the provided operation dictionary `op` (expects keys like "type" and "timestamp"), converts amounts using the snapshot's blockchain instance, and applies its effect to the snapshot by calling the appropriate update methods (e.g. update, update_rewards, update_out_vote, update_in_vote). Handles Hive-specific operations such as account creation, transfers, vesting/delegation, reward payouts, order fills, conversions, interest, votes, and hardfork-related adjustments. Many other operation types are intentionally ignored.
+
+        Parameters:
+            op (dict): A single operation entry from account history. Must contain a parsable "timestamp" and a "type" key; other required keys depend on the operation type.
+            only_ops (list): If non-empty, treat operations listed here as affecting balances/votes even when reward/vote-collection flags are disabled.
+            enable_rewards (bool): When True, record reward aggregates via update_rewards in addition to applying balance changes.
+            enable_out_votes (bool): When True, record outbound votes (this account as voter) via update_out_vote.
+            enable_in_votes (bool): When True, record inbound votes (this account as author/recipient) via update_in_vote.
+
+        Returns:
+            None
+        """
         ts = parse_time(op["timestamp"])
 
         if op["type"] == "account_create":
-            fee_steem = Amount(op["fee"], blockchain_instance=self.blockchain).amount
-            fee_vests = self.blockchain.sp_to_vests(
+            fee_hive = Amount(op["fee"], blockchain_instance=self.blockchain).amount
+            fee_vests = self.blockchain.hp_to_vests(
                 Amount(op["fee"], blockchain_instance=self.blockchain).amount, timestamp=ts
             )
             if op["new_account_name"] == self.account["name"]:
                 self.update(ts, fee_vests, 0, 0)
                 return
             if op["creator"] == self.account["name"]:
-                self.update(ts, 0, 0, 0, fee_steem * (-1), 0)
+                self.update(ts, 0, 0, 0, fee_hive * (-1), 0)
                 return
 
-        elif op["type"] == "account_create_with_delegation":
-            fee_steem = Amount(op["fee"], blockchain_instance=self.blockchain).amount
-            from nectar import Steem
-
-            if isinstance(self.blockchain, Steem):
-                fee_vests = self.blockchain.sp_to_vests(
-                    Amount(op["fee"], blockchain_instance=self.blockchain).amount, timestamp=ts
-                )
-            else:
-                fee_vests = self.blockchain.hp_to_vests(
-                    Amount(op["fee"], blockchain_instance=self.blockchain).amount, timestamp=ts
-                )
+        if op["type"] == "account_create_with_delegation":
+            fee_hive = Amount(op["fee"], blockchain_instance=self.blockchain).amount
+            fee_vests = self.blockchain.hp_to_vests(
+                Amount(op["fee"], blockchain_instance=self.blockchain).amount, timestamp=ts
+            )
             if op["new_account_name"] == self.account["name"]:
                 if Amount(op["delegation"], blockchain_instance=self.blockchain).amount > 0:
                     delegation = {
@@ -352,7 +434,7 @@ class AccountSnapshot(list):
                     "account": op["new_account_name"],
                     "amount": Amount(op["delegation"], blockchain_instance=self.blockchain),
                 }
-                self.update(ts, 0, 0, delegation, fee_steem * (-1), 0)
+                self.update(ts, 0, 0, delegation, fee_hive * (-1), 0)
                 return
 
         elif op["type"] == "delegate_vesting_shares":
@@ -370,14 +452,14 @@ class AccountSnapshot(list):
             amount = Amount(op["amount"], blockchain_instance=self.blockchain)
             if op["from"] == self.account["name"]:
                 if amount.symbol == self.blockchain.blockchain_symbol:
-                    self.update(ts, 0, 0, 0, amount * (-1), 0)
+                    self.update(ts, 0, None, None, hive=amount * (-1), hbd=0)
                 elif amount.symbol == self.blockchain.backed_token_symbol:
-                    self.update(ts, 0, 0, 0, 0, amount * (-1))
+                    self.update(ts, 0, None, None, hive=0, hbd=amount * (-1))
             if op["to"] == self.account["name"]:
                 if amount.symbol == self.blockchain.blockchain_symbol:
-                    self.update(ts, 0, 0, 0, amount, 0)
+                    self.update(ts, 0, None, None, hive=amount, hbd=0)
                 elif amount.symbol == self.blockchain.backed_token_symbol:
-                    self.update(ts, 0, 0, 0, 0, amount)
+                    self.update(ts, 0, None, None, hive=0, hbd=amount)
             return
 
         elif op["type"] == "fill_order":
@@ -385,35 +467,32 @@ class AccountSnapshot(list):
             open_pays = Amount(op["open_pays"], blockchain_instance=self.blockchain)
             if op["current_owner"] == self.account["name"]:
                 if current_pays.symbol == self.blockchain.token_symbol:
-                    self.update(ts, 0, 0, 0, current_pays * (-1), open_pays)
+                    self.update(ts, 0, None, None, hive=current_pays * (-1), hbd=open_pays)
                 elif current_pays.symbol == self.blockchain.backed_token_symbol:
-                    self.update(ts, 0, 0, 0, open_pays, current_pays * (-1))
+                    self.update(ts, 0, None, None, hive=open_pays, hbd=current_pays * (-1))
             if op["open_owner"] == self.account["name"]:
                 if current_pays.symbol == self.blockchain.token_symbol:
-                    self.update(ts, 0, 0, 0, current_pays, open_pays * (-1))
+                    self.update(ts, 0, None, None, hive=current_pays, hbd=open_pays * (-1))
                 elif current_pays.symbol == self.blockchain.backed_token_symbol:
-                    self.update(ts, 0, 0, 0, open_pays * (-1), current_pays)
+                    self.update(ts, 0, None, None, hive=open_pays * (-1), hbd=current_pays)
             return
 
         elif op["type"] == "transfer_to_vesting":
-            steem = Amount(op["amount"], blockchain_instance=self.blockchain)
-            from nectar import Steem
-
-            if isinstance(self.blockchain, Steem):
-                vests = self.blockchain.sp_to_vests(steem.amount, timestamp=ts)
-            else:
-                vests = self.blockchain.hp_to_vests(steem.amount, timestamp=ts)
+            hive_amt = Amount(op["amount"], blockchain_instance=self.blockchain)
+            vests = self.blockchain.hp_to_vests(hive_amt.amount, timestamp=ts)
             if op["from"] == self.account["name"] and op["to"] == self.account["name"]:
-                self.update(ts, vests, 0, 0, steem * (-1), 0)  # power up from and to given account
+                self.update(
+                    ts, vests, 0, 0, hive_amt * (-1), 0
+                )  # power up from and to given account
             elif op["from"] != self.account["name"] and op["to"] == self.account["name"]:
                 self.update(ts, vests, 0, 0, 0, 0)  # power up from another account
             else:  # op['from'] == self.account["name"] and op['to'] != self.account["name"]
-                self.update(ts, 0, 0, 0, steem * (-1), 0)  # power up to another account
+                self.update(ts, 0, 0, 0, hive_amt * (-1), 0)  # power up to another account
             return
 
         elif op["type"] == "fill_vesting_withdraw":
             vests = Amount(op["withdrawn"], blockchain_instance=self.blockchain)
-            self.update(ts, vests * (-1), 0, 0)
+            self.update(ts, vests * (-1), None, None, hive=0, hbd=0)
             return
 
         elif op["type"] == "return_vesting_delegation":
@@ -421,21 +500,21 @@ class AccountSnapshot(list):
                 "account": None,
                 "amount": Amount(op["vesting_shares"], blockchain_instance=self.blockchain),
             }
-            self.update(ts, 0, 0, delegation)
+            self.update(ts, 0, None, delegated_out=delegation)
             return
 
         elif op["type"] == "claim_reward_balance":
             vests = Amount(op["reward_vests"], blockchain_instance=self.blockchain)
-            steem = Amount(op["reward_steem"], blockchain_instance=self.blockchain)
-            sbd = Amount(op["reward_sbd"], blockchain_instance=self.blockchain)
-            self.update(ts, vests, 0, 0, steem, sbd)
+            hive = Amount(op["reward_hive"], blockchain_instance=self.blockchain)
+            hbd = Amount(op["reward_hbd"], blockchain_instance=self.blockchain)
+            self.update(ts, vests, None, None, hive=hive, hbd=hbd)
             return
 
         elif op["type"] == "curation_reward":
             if "curation_reward" in only_ops or enable_rewards:
                 vests = Amount(op["reward"], blockchain_instance=self.blockchain)
             if "curation_reward" in only_ops:
-                self.update(ts, vests, 0, 0)
+                self.update(ts, vests, None, None, hive=0, hbd=0)
             if enable_rewards:
                 self.update_rewards(ts, vests, 0, 0, 0)
             return
@@ -443,29 +522,29 @@ class AccountSnapshot(list):
         elif op["type"] == "author_reward":
             if "author_reward" in only_ops or enable_rewards:
                 vests = Amount(op["vesting_payout"], blockchain_instance=self.blockchain)
-                steem = Amount(op["steem_payout"], blockchain_instance=self.blockchain)
-                sbd = Amount(op["sbd_payout"], blockchain_instance=self.blockchain)
+                hive = Amount(op["hive_payout"], blockchain_instance=self.blockchain)
+                hbd = Amount(op["hbd_payout"], blockchain_instance=self.blockchain)
             if "author_reward" in only_ops:
-                self.update(ts, vests, 0, 0, steem, sbd)
+                self.update(ts, vests, None, None, hive=hive, hbd=hbd)
             if enable_rewards:
-                self.update_rewards(ts, 0, vests, steem, sbd)
+                self.update_rewards(ts, 0, vests, hive, hbd)
             return
 
         elif op["type"] == "producer_reward":
             vests = Amount(op["vesting_shares"], blockchain_instance=self.blockchain)
-            self.update(ts, vests, 0, 0)
+            self.update(ts, vests, None, None, hive=0, hbd=0)
             return
 
         elif op["type"] == "comment_benefactor_reward":
             if op["benefactor"] == self.account["name"]:
                 if "reward" in op:
                     vests = Amount(op["reward"], blockchain_instance=self.blockchain)
-                    self.update(ts, vests, 0, 0)
+                    self.update(ts, vests, None, None, hive=0, hbd=0)
                 else:
                     vests = Amount(op["vesting_payout"], blockchain_instance=self.blockchain)
-                    steem = Amount(op["steem_payout"], blockchain_instance=self.blockchain)
-                    sbd = Amount(op["sbd_payout"], blockchain_instance=self.blockchain)
-                    self.update(ts, vests, 0, 0, steem, sbd)
+                    hive = Amount(op["hive_payout"], blockchain_instance=self.blockchain)
+                    hbd = Amount(op["hbd_payout"], blockchain_instance=self.blockchain)
+                    self.update(ts, vests, None, None, hive=hive, hbd=hbd)
                 return
             else:
                 return
@@ -474,12 +553,12 @@ class AccountSnapshot(list):
             amount_in = Amount(op["amount_in"], blockchain_instance=self.blockchain)
             amount_out = Amount(op["amount_out"], blockchain_instance=self.blockchain)
             if op["owner"] == self.account["name"]:
-                self.update(ts, 0, 0, 0, amount_out, amount_in * (-1))
+                self.update(ts, 0, None, None, hive=amount_out, hbd=amount_in * (-1))
             return
 
         elif op["type"] == "interest":
             interest = Amount(op["interest"], blockchain_instance=self.blockchain)
-            self.update(ts, 0, 0, 0, 0, interest)
+            self.update(ts, 0, None, None, hive=0, hbd=interest)
             return
 
         elif op["type"] == "vote":
@@ -494,9 +573,9 @@ class AccountSnapshot(list):
 
         elif op["type"] == "hardfork_hive":
             vests = Amount(op["vests_converted"])
-            hbd = Amount(op["steem_transferred"])
-            hive = Amount(op["sbd_transferred"])
-            self.update(ts, vests * (-1), 0, 0, hive * (-1), hbd * (-1))
+            hbd = Amount(op["hbd_transferred"])
+            hive = Amount(op["hive_transferred"])
+            self.update(ts, vests * (-1), None, None, hive=hive * (-1), hbd=hbd * (-1))
 
         elif op["type"] in [
             "comment",
@@ -522,7 +601,19 @@ class AccountSnapshot(list):
             return
 
     def build_sp_arrays(self):
-        """Builds the own_sp and eff_sp array"""
+        """
+        Build timelines of own and effective Hive Power (HP) for each stored timestamp.
+
+        For every timestamp in the snapshot, convert the account's own vesting shares and the
+        sum of delegated-in/out vesting shares to Hive Power via the blockchain's
+        `vests_to_hp` conversion and populate:
+        - self.own_sp: HP equivalent of the account's own vesting shares at each timestamp.
+        - self.eff_sp: effective HP = own HP + HP delegated in - HP delegated out at each timestamp.
+
+        This method mutates self.own_sp and self.eff_sp in-place and relies on
+        self.timestamps, self.own_vests, self.delegated_vests_in, self.delegated_vests_out,
+        and self.blockchain.vests_to_hp(timestamp=...).
+        """
         self.own_sp = []
         self.eff_sp = []
         for ts, own, din, dout in zip(
@@ -530,16 +621,9 @@ class AccountSnapshot(list):
         ):
             sum_in = sum([din[key].amount for key in din])
             sum_out = sum([dout[key].amount for key in dout])
-            from nectar import Steem
-
-            if isinstance(self.blockchain, Steem):
-                sp_in = self.blockchain.vests_to_sp(sum_in, timestamp=ts)
-                sp_out = self.blockchain.vests_to_sp(sum_out, timestamp=ts)
-                sp_own = self.blockchain.vests_to_sp(own, timestamp=ts)
-            else:
-                sp_in = self.blockchain.vests_to_hp(sum_in, timestamp=ts)
-                sp_out = self.blockchain.vests_to_hp(sum_out, timestamp=ts)
-                sp_own = self.blockchain.vests_to_hp(own, timestamp=ts)
+            sp_in = self.blockchain.vests_to_hp(sum_in, timestamp=ts)
+            sp_out = self.blockchain.vests_to_hp(sum_out, timestamp=ts)
+            sp_own = self.blockchain.vests_to_hp(own, timestamp=ts)
 
             sp_eff = sp_own + sp_in - sp_out
             self.own_sp.append(sp_own)
@@ -558,30 +642,45 @@ class AccountSnapshot(list):
             self.rep_timestamp.append(ts)
 
     def build_vp_arrays(self):
-        """Build vote power arrays"""
+        """
+        Build timelines for upvote and downvote voting power.
+
+        Populates the following instance arrays with parallel timestamps and voting-power values:
+        - self.vp_timestamp, self.vp: upvoting power timeline
+        - self.downvote_vp_timestamp, self.downvote_vp: downvoting power timeline
+
+        The method iterates over recorded outgoing votes (self.out_vote_timestamp / self.out_vote_weight),
+        applies Hive vote-regeneration rules (using HIVE_VOTE_REGENERATION_SECONDS and HIVE_100_PERCENT),
+        accounts for the HF_21 downvote timing change, and models vote drains via the blockchain's
+        _vote/resulting calculation and the account's manabar recharge intervals (account.get_manabar_recharge_timedelta).
+        Values are stored as integer percentage units where HIVE_100_PERCENT (typically 10000) represents 100.00%.
+
+        Side effects:
+        - Modifies self.vp_timestamp, self.vp, self.downvote_vp_timestamp, and self.downvote_vp in place.
+        """
         self.vp_timestamp = [self.timestamps[1]]
-        self.vp = [STEEM_100_PERCENT]
+        self.vp = [HIVE_100_PERCENT]
         HF_21 = datetime(2019, 8, 27, 15, tzinfo=timezone.utc)
         if self.timestamps[1] > HF_21:
             self.downvote_vp_timestamp = [self.timestamps[1]]
         else:
             self.downvote_vp_timestamp = [HF_21]
-        self.downvote_vp = [STEEM_100_PERCENT]
+        self.downvote_vp = [HIVE_100_PERCENT]
 
         for ts, weight in zip(self.out_vote_timestamp, self.out_vote_weight):
             regenerated_vp = 0
             if ts > HF_21 and weight < 0:
                 self.downvote_vp.append(self.downvote_vp[-1])
-                if self.downvote_vp[-1] < STEEM_100_PERCENT:
+                if self.downvote_vp[-1] < HIVE_100_PERCENT:
                     regenerated_vp = (
                         ((ts - self.downvote_vp_timestamp[-1]).total_seconds())
-                        * STEEM_100_PERCENT
-                        / STEEM_VOTE_REGENERATION_SECONDS
+                        * HIVE_100_PERCENT
+                        / HIVE_VOTE_REGENERATION_SECONDS
                     )
                     self.downvote_vp[-1] += int(regenerated_vp)
 
-                if self.downvote_vp[-1] > STEEM_100_PERCENT:
-                    self.downvote_vp[-1] = STEEM_100_PERCENT
+                if self.downvote_vp[-1] > HIVE_100_PERCENT:
+                    self.downvote_vp[-1] = HIVE_100_PERCENT
                     recharge_time = self.account.get_manabar_recharge_timedelta(
                         {"current_mana_pct": self.downvote_vp[-2] / 100}
                     )
@@ -589,44 +688,44 @@ class AccountSnapshot(list):
                     self.downvote_vp_timestamp.append(
                         self.downvote_vp_timestamp[-1] + recharge_time
                     )
-                    self.downvote_vp.append(STEEM_100_PERCENT)
+                    self.downvote_vp.append(HIVE_100_PERCENT)
 
                 # Add charged downvote VP just before new Vote
                 self.downvote_vp_timestamp.append(ts - timedelta(seconds=1))
                 self.downvote_vp.append(
-                    min([STEEM_100_PERCENT, self.downvote_vp[-1] + regenerated_vp])
+                    min([HIVE_100_PERCENT, self.downvote_vp[-1] + regenerated_vp])
                 )
 
                 self.downvote_vp[-1] -= (
-                    self.blockchain._calc_resulting_vote(STEEM_100_PERCENT, weight) * 4
+                    self.blockchain._calc_resulting_vote(HIVE_100_PERCENT, weight) * 4
                 )
                 # Downvote mana pool is 1/4th of the upvote mana pool, so it gets drained 4 times as quick
                 if self.downvote_vp[-1] < 0:
                     # There's most likely a better solution to this that what I did here
                     self.vp.append(self.vp[-1])
 
-                    if self.vp[-1] < STEEM_100_PERCENT:
+                    if self.vp[-1] < HIVE_100_PERCENT:
                         regenerated_vp = (
                             ((ts - self.vp_timestamp[-1]).total_seconds())
-                            * STEEM_100_PERCENT
-                            / STEEM_VOTE_REGENERATION_SECONDS
+                            * HIVE_100_PERCENT
+                            / HIVE_VOTE_REGENERATION_SECONDS
                         )
                         self.vp[-1] += int(regenerated_vp)
 
-                    if self.vp[-1] > STEEM_100_PERCENT:
-                        self.vp[-1] = STEEM_100_PERCENT
+                    if self.vp[-1] > HIVE_100_PERCENT:
+                        self.vp[-1] = HIVE_100_PERCENT
                         recharge_time = self.account.get_manabar_recharge_timedelta(
                             {"current_mana_pct": self.vp[-2] / 100}
                         )
                         # Add full VP once fully charged
                         self.vp_timestamp.append(self.vp_timestamp[-1] + recharge_time)
-                        self.vp.append(STEEM_100_PERCENT)
-                    if self.vp[-1] == STEEM_100_PERCENT and ts - self.vp_timestamp[-1] > timedelta(
+                        self.vp.append(HIVE_100_PERCENT)
+                    if self.vp[-1] == HIVE_100_PERCENT and ts - self.vp_timestamp[-1] > timedelta(
                         seconds=1
                     ):
                         # Add charged VP just before new Vote
                         self.vp_timestamp.append(ts - timedelta(seconds=1))
-                        self.vp.append(min([STEEM_100_PERCENT, self.vp[-1] + regenerated_vp]))
+                        self.vp.append(min([HIVE_100_PERCENT, self.vp[-1] + regenerated_vp]))
                     self.vp[-1] += self.downvote_vp[-1] / 4
                     if self.vp[-1] < 0:
                         self.vp[-1] = 0
@@ -638,28 +737,28 @@ class AccountSnapshot(list):
             else:
                 self.vp.append(self.vp[-1])
 
-                if self.vp[-1] < STEEM_100_PERCENT:
+                if self.vp[-1] < HIVE_100_PERCENT:
                     regenerated_vp = (
                         ((ts - self.vp_timestamp[-1]).total_seconds())
-                        * STEEM_100_PERCENT
-                        / STEEM_VOTE_REGENERATION_SECONDS
+                        * HIVE_100_PERCENT
+                        / HIVE_VOTE_REGENERATION_SECONDS
                     )
                     self.vp[-1] += int(regenerated_vp)
 
-                if self.vp[-1] > STEEM_100_PERCENT:
-                    self.vp[-1] = STEEM_100_PERCENT
+                if self.vp[-1] > HIVE_100_PERCENT:
+                    self.vp[-1] = HIVE_100_PERCENT
                     recharge_time = self.account.get_manabar_recharge_timedelta(
                         {"current_mana_pct": self.vp[-2] / 100}
                     )
                     # Add full VP once fully charged
                     self.vp_timestamp.append(self.vp_timestamp[-1] + recharge_time)
-                    self.vp.append(STEEM_100_PERCENT)
-                if self.vp[-1] == STEEM_100_PERCENT and ts - self.vp_timestamp[-1] > timedelta(
+                    self.vp.append(HIVE_100_PERCENT)
+                if self.vp[-1] == HIVE_100_PERCENT and ts - self.vp_timestamp[-1] > timedelta(
                     seconds=1
                 ):
                     # Add charged VP just before new Vote
                     self.vp_timestamp.append(ts - timedelta(seconds=1))
-                    self.vp.append(min([STEEM_100_PERCENT, self.vp[-1] + regenerated_vp]))
+                    self.vp.append(min([HIVE_100_PERCENT, self.vp[-1] + regenerated_vp]))
                 self.vp[-1] -= self.blockchain._calc_resulting_vote(self.vp[-1], weight)
                 if self.vp[-1] < 0:
                     self.vp[-1] = 0
@@ -686,9 +785,37 @@ class AccountSnapshot(list):
         self.vp_timestamp.append(datetime.now(timezone.utc))
 
     def build_curation_arrays(self, end_date=None, sum_days=7):
-        """Build curation arrays"""
-        self.curation_per_1000_SP_timestamp = []
-        self.curation_per_1000_SP = []
+        """
+        Compute curation-per-1000-HP time series and store them in
+        self.curation_per_1000_HP_timestamp and self.curation_per_1000_HP.
+
+        The method walks through recorded reward timestamps and curation rewards, converts
+        each curation reward (vests) to HP using the blockchain conversion, and divides
+        that reward by the effective stake (sp_eff) at the reward time to produce a
+        "curation per 1000 HP" value. Values are aggregated into contiguous windows of
+        length `sum_days`. Each window's aggregate is appended to
+        self.curation_per_1000_HP with the corresponding window end timestamp in
+        self.curation_per_1000_HP_timestamp.
+
+        Parameters:
+            end_date (datetime.datetime | None): End-boundary for the first aggregation
+                window. If None, it is set to the last reward timestamp minus the total
+                span of full `sum_days` windows that fit into the reward history.
+            sum_days (int): Window length in days for aggregation. Must be > 0.
+
+        Raises:
+            ValueError: If sum_days <= 0.
+
+        Notes:
+            - Uses self.blockchain.vests_to_hp(vests, timestamp=ts) to convert vests to HP.
+            - Uses self.get_data(timestamp=ts, index=index) to obtain the effective stake
+              (`sp_eff`) and to advance a cached index for efficient lookups.
+            - The per-window aggregation normalizes values to a "per 1000 HP" basis and
+              scales them by (7 / sum_days) so the resulting numbers are comparable to a
+              7-day baseline.
+        """
+        self.curation_per_1000_HP_timestamp = []
+        self.curation_per_1000_HP = []
         if sum_days <= 0:
             raise ValueError("sum_days must be greater than 0")
         index = 0
@@ -699,12 +826,7 @@ class AccountSnapshot(list):
         for ts, vests in zip(self.reward_timestamps, self.curation_rewards):
             if vests == 0:
                 continue
-            from nectar import Steem
-
-            if isinstance(self.blockchain, Steem):
-                sp = self.blockchain.vests_to_sp(vests, timestamp=ts)
-            else:
-                sp = self.blockchain.vests_to_hp(vests, timestamp=ts)
+            sp = self.blockchain.vests_to_hp(vests, timestamp=ts)
             data = self.get_data(timestamp=ts, index=index)
             index = data["index"]
             if "sp_eff" in data and data["sp_eff"] > 0:
@@ -714,8 +836,8 @@ class AccountSnapshot(list):
             if ts < end_date:
                 curation_sum += curation_1k_sp
             else:
-                self.curation_per_1000_SP_timestamp.append(end_date)
-                self.curation_per_1000_SP.append(curation_sum)
+                self.curation_per_1000_HP_timestamp.append(end_date)
+                self.curation_per_1000_HP.append(curation_sum)
                 end_date = end_date + timedelta(days=sum_days)
                 curation_sum = 0