fix normalized weights

Author: Ramarti

data/0x8b6e6e7b5b3801fed2cafd4b22b8a16c2f2db21a-initial_pool_states-prices.json

@@ -2,13 +2,13 @@
 	"pool": {
 		"tokens": {
 			"DAI": {
-				"weight": "0.1",
+				"weight": "20.0",
 				"denorm_weight": "10",
 				"balance": "10000000",
 				"bound": true
 			},
 			"WETH": {
-				"weight": "0.4",
+				"weight": "80.0",
 				"denorm_weight": "40",
 				"balance": "67738.636173102396002749",
 				"bound": true

data/0x8b6e6e7b5b3801fed2cafd4b22b8a16c2f2db21a-initial_pool_states.json

@@ -2,13 +2,13 @@
 	"pool": {
 		"tokens": {
 			"DAI": {
-				"weight": "0.1",
+				"weight": "20.0",
 				"denorm_weight": "10",
 				"balance": "10000000",
 				"bound": true
 			},
 			"WETH": {
-				"weight": "0.4",
+				"weight": "80.0",
 				"denorm_weight": "40",
 				"balance": "67738.636173102396002749",
 				"bound": true

data/0xf9ab7776c7baeed1d65f0492fe2bb3951a1787ef-initial_pool_states.json

@@ -2,25 +2,29 @@
 	"pool": {
 		"tokens": {
 			"BAL": {
-				"weight": "0.25",
+				"weight": "50.0",
 				"denorm_weight": "25",
 				"balance": "2412.683823529411763228",
 				"bound": true
 			},
 			"WBTC": {
-				"weight": "0.17",
+				"weight": "34.00",
 				"denorm_weight": "17",
 				"balance": "18298383",
 				"bound": true
 			},
 			"WETH": {
-				"weight": "0.08",
+				"weight": "16.00",
 				"denorm_weight": "8",
 				"balance": "23.707607525864073665",
 				"bound": true
 			}
 		},
-		"generated_fees": 0.0,
+		"generated_fees": {
+			"BAL": "0.0",
+			"WBTC": "0.0",
+			"WETH": "0.0"
+		},
 		"pool_shares": "100",
 		"swap_fee": "0.0015"
 	},

data/pulldata.py

@@ -11,11 +11,9 @@
 from decimal import Decimal
 
 import dateutil
-import ipdb
 import pandas as pd
 from action import Action
 from google.cloud import bigquery
-from ipdb import launch_ipdb_on_exception
 from web3 import Web3
 
 from w3_utils import (BPoolLogCallParser, ERC20InfoReader,
@@ -42,10 +40,12 @@ def query(client, sql: str) -> pd.DataFrame:
     )
     return result
 
+
 def load_json(path):
     with open(path, 'r') as f:
         return json.load(f)
 
+
 def save_json(x, path, indent=True, **kwargs):
     with open(path, 'w') as f:
         if indent:
@@ -54,32 +54,41 @@ def save_json(x, path, indent=True, **kwargs):
             json.dump(x, f, **kwargs)
     print("Saved to", path)
 
+
 def load_pickle(path):
     print("Unpickling from", path)
     with open(path, 'rb') as f:
         return pickle.load(f)
 
+
 def save_pickle(x, path):
     print("Pickling to", path)
     with open(path, 'wb') as f:
         return pickle.dump(x, f)
 
+
 def save_queries_pickle(pool_address: str, event_type: str, df: pd.DataFrame):
     filename = f"{pool_address}/{event_type}.pickle"
     save_pickle(df, filename)
 
+
 def query_and_save(client, pool_address: str, event_type: str, sql: str, writer) -> pd.DataFrame:
     df = query(client, sql)
     writer(pool_address, event_type, df)
     return df
 
+
 def get_initial_token_distribution(new_results) -> dict:
     receipt = w3.eth.getTransactionReceipt(new_results.iloc[0]['transaction_hash'])
     events = log_call_parser.parse_from_receipt(receipt, args.pool_address)
     bind_events = list(filter(lambda x: x['type'] == 'bind', events))
+    unique_bind_events = []
+    for event in bind_events:
+        if event not in unique_bind_events:
+            unique_bind_events.append(event)
     tokens = {}
     total_denorm_weight = Decimal('0.0')
-    for event in bind_events:
+    for event in unique_bind_events:
         inputs = event['inputs']
         token_address = inputs['token']
         token_symbol = erc20_info_getter.get_token_symbol(token_address)
@@ -92,23 +101,27 @@ def get_initial_token_distribution(new_results) -> dict:
             'balance': inputs['balance'],
             'bound': True
         }
+
     for (key, token) in tokens.items():
         denorm = Decimal(token['denorm_weight'])
-        token['weight'] = str(denorm / total_denorm_weight)
+        token['weight'] = str(Decimal('100') * (denorm / total_denorm_weight))
     return tokens
 
+
 def get_initial_fees_generated(pool_tokens):
     fees = {}
     for token_symbol in pool_tokens:
         fees[token_symbol] = '0.0'
     return fees
 
+
 def get_initial_pool_share(transfer_results, tx_hash):
     initial_tx_transfers = transfer_results.loc[transfer_results['transaction_hash'] == tx_hash]
     minting = initial_tx_transfers.loc[initial_tx_transfers['src'] == '0x0000000000000000000000000000000000000000']
     wei_amount = int(minting.iloc[0]['amt'])
     return Web3.fromWei(wei_amount, 'ether')
 
+
 def format_denorms(denorms: dict) -> typing.List[typing.Dict]:
     """
     format_denorms expects the input to be
@@ -124,6 +137,7 @@ def format_denorms(denorms: dict) -> typing.List[typing.Dict]:
         d.append(a)
     return d
 
+
 def classify_pool_share_transfers(transfers: []) -> (str, str):
     pool_share_burnt = list(filter(lambda x: x['dst'] == ZERO_ADDRESS, transfers))
     if len(pool_share_burnt) > 0:
@@ -133,6 +147,7 @@ def classify_pool_share_transfers(transfers: []) -> (str, str):
         return 'pool_amount_out', str(Web3.fromWei(int(pool_share_minted[0]['amt']), 'ether'))
     raise Exception('not pool share mint or burn', transfers)
 
+
 def map_token_amounts(txs: [], address_key: str, amount_key: str):
     def map_tx(x):
         mapped = {}
@@ -143,6 +158,7 @@ def map_tx(x):
 
     return list(map(map_tx, txs))
 
+
 def classify_actions(group):
     action = {}
     transfers = list(filter(lambda x: x.action_type == 'transfer', group))
@@ -186,6 +202,7 @@ def classify_actions(group):
         action['type'] = 'exit_swap'
     return action
 
+
 def turn_events_into_actions(events_list, fees: typing.Dict, denorms: pd.DataFrame) -> typing.List[Action]:
     actions = []
     grouped = events_list.groupby("transaction_hash")
@@ -203,11 +220,12 @@ def turn_events_into_actions(events_list, fees: typing.Dict, denorms: pd.DataFra
         # convert block_number and swap_fee to string to painlessly
         # convert to JSON later (numpy.int64 can't be JSON serialized)
         a = Action(timestamp=ts.to_pydatetime(), tx_hash=tx_hash, block_number=str(block_number), swap_fee=str(fee),
-                    denorms=denorm, action_type=first_event_log["type"], action=events.to_dict(orient="records"))
+                   denorms=denorm, action_type=first_event_log["type"], action=events.to_dict(orient="records"))
         actions.append(a)
 
     return actions
 
+
 def stage1_load_sql_data(pool_address: str):
     try:
         new_results = load_pickle(f"{pool_address}/new.pickle")
@@ -255,6 +273,7 @@ def stage1_load_sql_data(pool_address: str):
 
     return new_results, join_results, swap_results, exit_results, transfer_results, fees_results, denorms_results
 
+
 def stage2_produce_initial_state(new_results, fees_results, transfer_results) -> typing.Dict:
     tokens = get_initial_token_distribution(new_results)
     generated_fees = get_initial_fees_generated(tokens)
@@ -274,6 +293,7 @@ def stage2_produce_initial_state(new_results, fees_results, transfer_results) ->
     }
     return initial_states
 
+
 def stage3_merge_actions(pool_address, grouped_actions):
     filename = f"{pool_address}/txhash_contractcalls.json"
     try:
@@ -310,6 +330,7 @@ def stage3_merge_actions(pool_address, grouped_actions):
     actions_final.sort(key=lambda a: a['timestamp'])
     return actions_final
 
+
 def stage4_add_prices_to_initialstate_and_actions(pool_address: str, fiat_symbol: str, initial_state: typing.Dict, actions: typing.List[typing.Dict]):
     def parse_price_feeds(token_symbols: []) -> []:
         if len(price_feed_paths) != len(token_symbols):
@@ -368,16 +389,19 @@ def get_price_feeds_tokens(initial_state: typing.Dict):
 
     def add_price_feeds_to_actions(actions: typing.List[typing.Dict]) -> typing.List[typing.Dict]:
         actions.extend(price_actions)
+
         def equalize_date_types(action):
             if not isinstance(action['timestamp'], datetime):
                 action['timestamp'] = dateutil.parser.isoparse(action['timestamp'])
             return action
+
         actions = list(map(equalize_date_types, actions))
         actions.sort(key=lambda x: x['timestamp'])
 
         def convert_to_iso_str(action):
             action['timestamp'] = action['timestamp'].isoformat()
             return action
+
         actions = list(map(convert_to_iso_str, actions))
 
         # Remove prices before pool creation. First action must be pool creation
@@ -445,22 +469,26 @@ def produce_actions():
     # grouped_actions = load_pickle("{}/grouped_actions.pickle".format(args.pool_address))
 
     actions_final = stage3_merge_actions(args.pool_address, grouped_actions)
+
     def prep_json_serialize(o):
         if isinstance(o, datetime):
             return o.isoformat()
+
     save_json(actions_final, f"{args.pool_address}-actions.json", default=prep_json_serialize)
 
     # save_pickle(actions_final, f"{args.pool_address}/actions_final.pickle")
     # actions_final = load_pickle(f"{args.pool_address}/actions_final.pickle")
 
     if args.fiat:
-        initial_state_w_prices, actions_w_prices = stage4_add_prices_to_initialstate_and_actions(args.pool_address, args.fiat, initial_state, actions_final)
+        initial_state_w_prices, actions_w_prices = stage4_add_prices_to_initialstate_and_actions(args.pool_address, args.fiat, initial_state,
+                                                                                                 actions_final)
         save_json(initial_state_w_prices, f'{args.pool_address}-initial_pool_states-prices.json')
         save_json(actions_w_prices, f'{args.pool_address}-actions-prices.json')
     else:
         print("Fiat base for token prices not given - skipping price data injection")
 
-from ipdb import launch_ipdb_on_exception
 
-with launch_ipdb_on_exception():
-    produce_actions()
+# from ipdb import launch_ipdb_on_exception
+
+# with launch_ipdb_on_exception():
+produce_actions()