transaction history /value

Author: Yostra

electron-ui/cc_wallet/cc_wallet_renderer.js

@@ -252,10 +252,12 @@ function get_wallet_balance_response(response) {
         var confirmed = parseInt(response["confirmed_wallet_balance"])
         var unconfirmed = parseInt(response["unconfirmed_wallet_balance"])
         var pending = confirmed - unconfirmed
-        var wallet_id = response["wallet_id"]
 
+        var wallet_id = response["wallet_id"]
+        console.log("wallet_id = " + wallet_id + "confirmed: " + confirmed + "unconfirmed: " + unconfirmed )
         chia_confirmed = chia_formatter(confirmed, 'mojo').to('chia').toString()
         chia_pending = chia_formatter(pending, 'mojo').to('chia').toString()
+        chia_pending_abs = chia_formatter(Math.abs(pending), 'mojo').to('chia').toString()
 
         wallet_balance_holder = document.querySelector("#" + "balance_wallet_" + wallet_id )
         wallet_pending_holder = document.querySelector("#" + "pending_wallet_" + wallet_id )
@@ -265,7 +267,7 @@ function get_wallet_balance_response(response) {
             if (pending > 0) {
                 pending_textfield.innerHTML = lock + " - " + chia_pending + " CH"
             } else {
-                pending_textfield.innerHTML = lock + " " + chia_pending + " CH"
+                pending_textfield.innerHTML = lock + " " + chia_pending_abs + " CH"
             }
         }
         if (wallet_balance_holder) {
@@ -275,7 +277,7 @@ function get_wallet_balance_response(response) {
             if (pending > 0) {
                 wallet_pending_holder.innerHTML = lock + " - " + chia_pending + " CH"
             } else {
-                wallet_pending_holder.innerHTML = lock + " " + chia_pending + " CH"
+                wallet_pending_holder.innerHTML = lock + " " + chia_pending_abs + " CH"
             }
         }
     }

electron-ui/renderer.js

@@ -323,10 +323,12 @@ function get_wallet_balance_response(response) {
         var confirmed = parseInt(response["confirmed_wallet_balance"])
         var unconfirmed = parseInt(response["unconfirmed_wallet_balance"])
         var pending = confirmed - unconfirmed
-        var wallet_id = response["wallet_id"]
 
+        var wallet_id = response["wallet_id"]
+        console.log("wallet_id = " + wallet_id + "confirmed: " + confirmed + "unconfirmed: " + unconfirmed )
         chia_confirmed = chia_formatter(confirmed, 'mojo').to('chia').toString()
         chia_pending = chia_formatter(pending, 'mojo').to('chia').toString()
+        chia_pending_abs = chia_formatter(Math.abs(pending), 'mojo').to('chia').toString()
 
         wallet_balance_holder = document.querySelector("#" + "balance_wallet_" + wallet_id )
         wallet_pending_holder = document.querySelector("#" + "pending_wallet_" + wallet_id )
@@ -336,7 +338,7 @@ function get_wallet_balance_response(response) {
             if (pending > 0) {
                 pending_textfield.innerHTML = lock + " - " + chia_pending + " CH"
             } else {
-                pending_textfield.innerHTML = lock + " " + chia_pending + " CH"
+                pending_textfield.innerHTML = lock + " " + chia_pending_abs + " CH"
             }
         }
         if (wallet_balance_holder) {
@@ -346,7 +348,7 @@ function get_wallet_balance_response(response) {
             if (pending > 0) {
                 wallet_pending_holder.innerHTML = lock + " - " + chia_pending + " CH"
             } else {
-                wallet_pending_holder.innerHTML = lock + " " + chia_pending + " CH"
+                wallet_pending_holder.innerHTML = lock + " " + chia_pending_abs + " CH"
             }
         }
     }

electron-ui/trade_renderer.js

@@ -220,6 +220,7 @@ function get_wallet_balance_response(response) {
 
         chia_confirmed = chia_formatter(confirmed, 'mojo').to('chia').toString()
         chia_pending = chia_formatter(pending, 'mojo').to('chia').toString()
+        chia_pending_abs = chia_formatter(Math.abs(pending), 'mojo').to('chia').toString()
 
         wallet_balance_holder = document.querySelector("#" + "balance_wallet_" + wallet_id )
         wallet_pending_holder = document.querySelector("#" + "pending_wallet_" + wallet_id )
@@ -231,7 +232,7 @@ function get_wallet_balance_response(response) {
             if (pending > 0) {
                 wallet_pending_holder.innerHTML = lock + " - " + chia_pending + " CH"
             } else {
-                wallet_pending_holder.innerHTML = lock + " " + chia_pending + " CH"
+                wallet_pending_holder.innerHTML = lock + " " + chia_pending_abs + " CH"
             }
         }
     }

src/types/spend_bundle.py

@@ -73,3 +73,15 @@ def not_ephemeral_spends(self):
             result.append(rem)
 
         return result
+
+    def not_ephemeral_additions(self):
+        all_removals = self.removals()
+        all_additions = self.additions()
+        result: List[Coin] = []
+
+        for add in all_additions:
+            if add in all_removals:
+                continue
+            result.append(add)
+
+        return result

src/wallet/cc_wallet/cc_wallet.py

@@ -1,4 +1,5 @@
 import logging
+import time
 
 import clvm
 from typing import Dict, Optional, List, Any, Set
@@ -27,6 +28,7 @@
     create_spend_for_ephemeral,
 )
 from src.wallet.cc_wallet.ccparent import CCParent
+from src.wallet.transaction_record import TransactionRecord
 from src.wallet.util.json_util import dict_to_json_str
 from src.wallet.util.wallet_types import WalletType
 from src.wallet.wallet import Wallet
@@ -75,14 +77,62 @@ async def create_new_cc(
             "CC Wallet", WalletType.COLOURED_COIN, info_as_string
         )
         if self.wallet_info is None:
-            raise
+            raise ValueError("Internal Error")
 
         spend_bundle = await self.generate_new_coloured_coin(amount)
         if spend_bundle is None:
-            raise
+            raise ValueError("Internal Error, unable to generate new coloured coin")
 
         await self.wallet_state_manager.add_new_wallet(self, self.wallet_info.id)
-        await self.standard_wallet.push_transaction(spend_bundle)
+
+        # Change and actual coloured coin
+        non_ephemeral_spends: List[Coin] = spend_bundle.not_ephemeral_additions()
+        cc_coin = None
+        puzzle_store = self.wallet_state_manager.puzzle_store
+
+        for c in non_ephemeral_spends:
+            info = await puzzle_store.wallet_info_for_puzzle_hash(c.puzzle_hash)
+            if info is None:
+                raise ValueError("Internal Error")
+            id, wallet_type = info
+            if id == self.wallet_info.id:
+                cc_coin = c
+
+        if cc_coin is None:
+            raise ValueError("Internal Error, unable to generate new coloured coin")
+
+        regular_record = TransactionRecord(
+            confirmed_at_index=uint32(0),
+            created_at_time=uint64(int(time.time())),
+            to_puzzle_hash=cc_coin.puzzle_hash,
+            amount=uint64(cc_coin.amount),
+            fee_amount=uint64(0),
+            incoming=False,
+            confirmed=False,
+            sent=uint32(0),
+            spend_bundle=spend_bundle,
+            additions=spend_bundle.additions(),
+            removals=spend_bundle.removals(),
+            wallet_id=self.wallet_state_manager.main_wallet.wallet_info.id,
+            sent_to=[],
+        )
+        cc_record = TransactionRecord(
+            confirmed_at_index=uint32(0),
+            created_at_time=uint64(int(time.time())),
+            to_puzzle_hash=cc_coin.puzzle_hash,
+            amount=uint64(cc_coin.amount),
+            fee_amount=uint64(0),
+            incoming=True,
+            confirmed=False,
+            sent=uint32(10),
+            spend_bundle=None,
+            additions=spend_bundle.additions(),
+            removals=spend_bundle.removals(),
+            wallet_id=self.wallet_info.id,
+            sent_to=[],
+        )
+        await self.standard_wallet.push_transaction(regular_record)
+        await self.standard_wallet.push_transaction(cc_record)
         return self
 
     @staticmethod
@@ -154,20 +204,18 @@ async def get_confirmed_balance(self) -> uint64:
 
     async def get_unconfirmed_balance(self) -> uint64:
         confirmed = await self.get_confirmed_balance()
-        unconfirmed_tx = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(
+        unconfirmed_tx: List[TransactionRecord] = await self.wallet_state_manager.tx_store.get_unconfirmed_for_wallet(
             self.wallet_info.id
         )
         addition_amount = 0
         removal_amount = 0
 
         for record in unconfirmed_tx:
-            for coin in record.additions:
-                if await self.wallet_state_manager.puzzle_store.puzzle_hash_exists(
-                    coin.puzzle_hash
-                ):
-                    addition_amount += coin.amount
-            for coin in record.removals:
-                removal_amount += coin.amount
+            if record.incoming:
+                addition_amount += record.amount
+            else:
+                removal_amount += record.amount
+
         result = confirmed - removal_amount + addition_amount
 
         self.log.info(f"Unconfirmed balance for cc wallet is {result}")
@@ -426,16 +474,16 @@ async def generate_zero_val_coin(
         cc_puzzle = cc_wallet_puzzles.cc_make_puzzle(cc_inner, self.cc_info.my_core)
         cc_puzzle_hash = cc_puzzle.get_tree_hash()
 
-        spend_bundle = await self.standard_wallet.generate_signed_transaction(
+        tx = await self.standard_wallet.generate_signed_transaction(
             uint64(0), cc_puzzle_hash, uint64(0), origin_id, coins
         )
         self.log.warning(f"cc_puzzle_hash is {cc_puzzle_hash}")
         eve_coin = Coin(origin_id, cc_puzzle_hash, uint64(0))
-        if spend_bundle is None:
+        if tx is None or tx.spend_bundle is None:
             return None
 
         eve_spend = cc_generate_eve_spend(eve_coin, cc_puzzle)
-        full_spend = SpendBundle.aggregate([spend_bundle, eve_spend])
+        full_spend = SpendBundle.aggregate([tx.spend_bundle, eve_spend])
 
         future_parent = CCParent(eve_coin.parent_coin_info, cc_inner, eve_coin.amount)
         eve_parent = CCParent(
@@ -446,7 +494,39 @@ async def generate_zero_val_coin(
         await self.add_parent(eve_coin.parent_coin_info, eve_parent)
 
         if send:
-            await self.standard_wallet.push_transaction(full_spend)
+            regular_record = TransactionRecord(
+                confirmed_at_index=uint32(0),
+                created_at_time=uint64(int(time.time())),
+                to_puzzle_hash=cc_puzzle_hash,
+                amount=uint64(0),
+                fee_amount=uint64(0),
+                incoming=False,
+                confirmed=False,
+                sent=uint32(10),
+                spend_bundle=full_spend,
+                additions=full_spend.additions(),
+                removals=full_spend.removals(),
+                wallet_id=uint32(1),
+                sent_to=[],
+            )
+            cc_record = TransactionRecord(
+                confirmed_at_index=uint32(0),
+                created_at_time=uint64(int(time.time())),
+                to_puzzle_hash=cc_puzzle_hash,
+                amount=uint64(0),
+                fee_amount=uint64(0),
+                incoming=True,
+                confirmed=False,
+                sent=uint32(0),
+                spend_bundle=full_spend,
+                additions=full_spend.additions(),
+                removals=full_spend.removals(),
+                wallet_id=self.wallet_info.id,
+                sent_to=[],
+            )
+            await self.wallet_state_manager.add_transaction(regular_record)
+            await self.wallet_state_manager.add_pending_transaction(cc_record)
+
         return full_spend
 
     async def get_cc_spendable_coins(self) -> List[WalletCoinRecord]:
@@ -676,8 +756,23 @@ async def cc_spend(
         aggsig = BLSSignature.aggregate(sigs)
         spend_bundle = SpendBundle(list_of_solutions, aggsig)
 
+        tx_record = TransactionRecord(
+            confirmed_at_index=uint32(0),
+            created_at_time=uint64(int(time.time())),
+            to_puzzle_hash=to_address,
+            amount=uint64(amount),
+            fee_amount=uint64(0),
+            incoming=False,
+            confirmed=False,
+            sent=uint32(0),
+            spend_bundle=spend_bundle,
+            additions=spend_bundle.additions(),
+            removals=spend_bundle.removals(),
+            wallet_id=self.wallet_info.id,
+            sent_to=[],
+        )
         await self.wallet_state_manager.add_pending_transaction(
-            spend_bundle, self.wallet_info.id
+            tx_record
         )
 
         return spend_bundle
@@ -725,17 +820,17 @@ async def generate_new_coloured_coin(self, amount: uint64) -> Optional[SpendBund
         cc_puzzle = cc_wallet_puzzles.cc_make_puzzle(cc_inner, cc_core)
         cc_puzzle_hash = cc_puzzle.get_tree_hash()
 
-        spend_bundle = await self.standard_wallet.generate_signed_transaction(
+        tx_record: Optional[TransactionRecord] = await self.standard_wallet.generate_signed_transaction(
             amount, cc_puzzle_hash, uint64(0), origin_id, coins
         )
         self.log.warning(f"cc_puzzle_hash is {cc_puzzle_hash}")
         eve_coin = Coin(origin_id, cc_puzzle_hash, amount)
-        if spend_bundle is None:
+        if tx_record is None or tx_record.spend_bundle is None:
             return None
 
         eve_spend = cc_generate_eve_spend(eve_coin, cc_puzzle)
 
-        full_spend = SpendBundle.aggregate([spend_bundle, eve_spend])
+        full_spend = SpendBundle.aggregate([tx_record.spend_bundle, eve_spend])
         return full_spend
 
     async def create_spend_bundle_relative_amount(

src/wallet/trade_manager.py

@@ -1,4 +1,6 @@
+import time
 from pathlib import Path
+from secrets import token_bytes
 from typing import Dict, Optional, Tuple, List, Any
 import logging
 
@@ -10,13 +12,14 @@
 from src.types.program import Program
 from src.types.sized_bytes import bytes32
 from src.types.spend_bundle import SpendBundle
-from src.util.ints import uint32
+from src.util.ints import uint32, uint64
 from src.wallet.cc_wallet import cc_wallet_puzzles
 from src.wallet.cc_wallet.cc_wallet import CCWallet
 from src.wallet.cc_wallet.cc_wallet_puzzles import (
     create_spend_for_auditor,
     create_spend_for_ephemeral,
 )
+from src.wallet.transaction_record import TransactionRecord
 from src.wallet.wallet import Wallet
 from src.wallet.wallet_state_manager import WalletStateManager
 from clvm_tools import binutils
@@ -476,8 +479,22 @@ async def respond_to_offer(self, file_path: Path) -> bool:
             zero_spend_list.append(spend_bundle)
             spend_bundle = SpendBundle.aggregate(zero_spend_list)
 
-        await self.wallet_state_manager.add_pending_transaction(
-            spend_bundle, self.wallet_state_manager.main_wallet.wallet_info.id
+        tx_record = TransactionRecord(
+            confirmed_at_index=uint32(0),
+            created_at_time=uint64(int(time.time())),
+            to_puzzle_hash=token_bytes(),
+            amount=uint64(0),
+            fee_amount=uint64(0),
+            incoming=False,
+            confirmed=False,
+            sent=uint32(0),
+            spend_bundle=spend_bundle,
+            additions=spend_bundle.additions(),
+            removals=spend_bundle.removals(),
+            wallet_id=uint32(1),
+            sent_to=[],
         )
 
+        await self.wallet_state_manager.add_pending_transaction(tx_record)
+
         return True

src/wallet/transaction_record.py

@@ -4,6 +4,7 @@
 from src.types.coin import Coin
 from src.types.spend_bundle import SpendBundle
 from src.types.sized_bytes import bytes32
+from src.util.hash import std_hash
 from src.util.streamable import Streamable, streamable
 from src.util.ints import uint32, uint64, uint8
 
@@ -35,4 +36,4 @@ class TransactionRecord(Streamable):
     def name(self) -> bytes32:
         if self.spend_bundle:
             return self.spend_bundle.name()
-        return self.get_hash()
+        return std_hash(bytes(self.to_puzzle_hash) + bytes(self.created_at_time) + bytes(self.amount))