lunalib 1.7.3__py3-none-any.whl → 1.7.9__py3-none-any.whl

lunalib/.gitignore

@@ -0,0 +1,3 @@
+.venv
+build
+.__pycache__

lunalib/core/mempool.py

@@ -211,6 +211,7 @@ class MempoolManager:
             to_norm = self._normalize_address(tx.get('to') or tx.get('receiver'))
             if target_norm and (from_norm == target_norm or to_norm == target_norm):
                 transactions.append(tx)
+        print(f"[MEMPOOL] get_pending_transactions for {address}: {len(transactions)} txs returned")
         return transactions
 
     def get_pending_transactions_for_addresses(self, addresses: List[str], fetch_remote: bool = True) -> Dict[str, List[Dict]]:

lunalib/core/wallet.py

@@ -1,3 +1,37 @@
+def update_all_balances(self):
+    """Unified balance update: recalculates and persists balances."""
+    # 残高計算前にキャッシュを最新化
+    self._refresh_tx_caches()
+    available = self.calculate_available_balance()
+    # Optionally, persist to DB if needed
+    if self.current_wallet_address in self.wallets:
+        w = self.wallets[self.current_wallet_address]
+        if hasattr(self, 'db') and self.db:
+            self.db.save_wallet(
+                self.current_wallet_address,
+                w.get("label", ""),
+                w.get("public_key", ""),
+                w.get("encrypted_private_key", b""),
+                w.get("is_locked", True),
+                w.get("created", 0),
+                self.balance,
+                available
+            )
+    print(f"[WALLET] update_all_balances: balance={self.balance}, available={self.available_balance}")
+
+def _refresh_tx_caches(self):
+    """Force refresh of confirmed and pending tx caches for the current wallet."""
+    if not self.current_wallet_address:
+        return
+    from lunalib.core.blockchain import BlockchainManager
+    from lunalib.core.mempool import MempoolManager
+    blockchain = BlockchainManager()
+    mempool = MempoolManager()
+    confirmed = blockchain.scan_transactions_for_address(self.current_wallet_address)
+    pending = mempool.get_pending_transactions(self.current_wallet_address, fetch_remote=True)
+    self._confirmed_tx_cache[self.current_wallet_address] = confirmed
+    self._pending_tx_cache[self.current_wallet_address] = pending
+
 import time
 import hashlib
 import json
@@ -16,6 +50,7 @@ from .wallet_db import WalletDB
 class LunaWallet:
     def __init__(self, data_dir=None):
         self.data_dir = data_dir or os.path.expanduser("~/.lunawallet")
+        print(f"[LunaWallet] data_dir: {self.data_dir}")
         self.db = WalletDB(self.data_dir)
         self.wallets = {}  # address -> wallet dict (in-memory cache)
         self.current_wallet_address = None
@@ -399,16 +434,19 @@ class LunaWallet:
     def calculate_available_balance(self) -> float:
         """Calculate available balance (total balance minus pending outgoing transactions)"""
         try:
-            # Get total balance from blockchain
-            total_balance = self._get_total_balance_from_blockchain()
+            from lunalib.core.blockchain import BlockchainManager
+            blockchain = BlockchainManager()
+            current_height = blockchain.get_blockchain_height()
 
-            # Get pending outgoing amount
-            pending_outgoing = self._get_pending_balance()
+            # Get confirmed transactions for this wallet
+            confirmed = self._confirmed_tx_cache.get(self.address, [])
+            total_balance = self._compute_confirmed_balance(confirmed, current_height)
 
-            # Also check for any incoming pending transactions
-            incoming_pending = self._get_pending_incoming_balance()
+            # Get pending transactions for this wallet
+            pending = self._pending_tx_cache.get(self.address, [])
+            pending_out, pending_in = self._compute_pending_totals(pending, self.address, current_height)
 
-            available_balance = max(0.0, total_balance - pending_outgoing)
+            available_balance = max(0.0, total_balance - pending_out)
 
             # Update both current wallet and wallets collection
             self.available_balance = available_balance
@@ -421,11 +459,11 @@ class LunaWallet:
                 self.wallets[self.current_wallet_address]["balance"] = total_balance
 
             print(
-                f"DEBUG: Balance calculated - Total: {total_balance}, Pending Out: {pending_outgoing}, Available: {available_balance}"
+                f"DEBUG: Balance calculated - Total: {total_balance}, Pending Out: {pending_out}, Pending In: {pending_in}, Available: {available_balance}"
             )
 
-            if incoming_pending > 0:
-                print(f"DEBUG: Also {incoming_pending} LUN incoming (pending)")
+            if pending_in > 0:
+                print(f"DEBUG: Also {pending_in} LUN incoming (pending)")
 
             return available_balance
 
@@ -434,15 +472,30 @@ class LunaWallet:
             return self.balance  # Fallback to total balance
 
     def _compute_confirmed_balance(self, transactions: List[Dict]) -> float:
-        """Compute confirmed balance from a list of transactions."""
+        """Compute confirmed balance from a list of transactions, using confirmation count for rewards."""
         total_balance = 0.0
+        current_height = None
+        import inspect
+        # Try to get current_height from caller if passed
+        frame = inspect.currentframe().f_back
+        if frame and 'current_height' in frame.f_locals:
+            current_height = frame.f_locals['current_height']
         for tx in transactions:
             tx_type = (tx.get("type") or "").lower()
             direction = tx.get("direction", "")
             amount = float(tx.get("amount", 0) or 0)
+            block_height = tx.get("block_height")
+            confirmations = None
+            if block_height is not None and current_height is not None:
+                try:
+                    confirmations = int(current_height) - int(block_height) + 1
+                except Exception:
+                    confirmations = None
 
             if tx_type == "reward" or tx.get("from") == "network":
-                total_balance += amount
+                # Only count as confirmed if confirmations >= 6
+                if confirmations is not None and confirmations >= 6:
+                    total_balance += amount
             elif direction == "incoming":
                 total_balance += amount
             elif direction == "outgoing":
@@ -453,9 +506,9 @@ class LunaWallet:
         return max(0.0, total_balance)
 
     def _compute_pending_totals(
-        self, pending_txs: List[Dict], address: str
+        self, pending_txs: List[Dict], address: str, current_height: int = None
     ) -> Tuple[float, float]:
-        """Return (pending_outgoing, pending_incoming) for an address."""
+        """Return (pending_outgoing, pending_incoming) for an address, including pending rewards (<6 confs)."""
         pending_out = 0.0
         pending_in = 0.0
 
@@ -463,14 +516,26 @@ class LunaWallet:
         for tx in pending_txs:
             from_norm = self._normalize_address(tx.get("from") or tx.get("sender"))
             to_norm = self._normalize_address(tx.get("to") or tx.get("receiver"))
+            tx_type = (tx.get("type") or "").lower()
+            amount = float(tx.get("amount", 0) or 0)
+            block_height = tx.get("block_height")
+            confirmations = None
+            if block_height is not None and current_height is not None:
+                try:
+                    confirmations = int(current_height) - int(block_height) + 1
+                except Exception:
+                    confirmations = None
 
             if from_norm == target_norm:
-                amount = float(tx.get("amount", 0) or 0)
                 fee = float(tx.get("fee", 0) or tx.get("gas", 0) or 0)
                 pending_out += amount + fee
             if to_norm == target_norm:
-                amount = float(tx.get("amount", 0) or 0)
-                pending_in += amount
+                # For rewards, only count as pending if confirmations < 6
+                if tx_type == "reward" or tx.get("from") == "network":
+                    if confirmations is not None and confirmations < 6:
+                        pending_in += amount
+                else:
+                    pending_in += amount
 
         return pending_out, pending_in
 
@@ -503,7 +568,7 @@ class LunaWallet:
         return updated
 
     def refresh_all_wallet_balances(self) -> Dict[str, Dict[str, float]]:
-        """Scan blockchain once for all wallets, then update balances with pending mempool data."""
+        """Scan blockchain and mempool for all wallets, update balances and pending info."""
         addresses = list(self.wallets.keys())
         if not addresses:
             return {}
@@ -516,15 +581,44 @@ class LunaWallet:
             mempool = MempoolManager()
 
             confirmed_map = blockchain.scan_transactions_for_addresses(addresses)
-            pending_map = mempool.get_pending_transactions_for_addresses(
-                addresses, fetch_remote=True
-            )
+            pending_map = mempool.get_pending_transactions_for_addresses(addresses, fetch_remote=True)
 
             # Reset caches with the latest snapshots
             self._confirmed_tx_cache = confirmed_map
             self._pending_tx_cache = pending_map
 
-            return self._recompute_balances_from_cache()
+            # Recompute balances and pending for all wallets
+            updated: Dict[str, Dict[str, float]] = {}
+            for addr in addresses:
+                confirmed = confirmed_map.get(addr, [])
+                pending = pending_map.get(addr, [])
+                # 最新のブロック高を取得
+                try:
+                    current_height = blockchain.get_blockchain_height()
+                except Exception:
+                    current_height = None
+                total_balance = max(0.0, self._compute_confirmed_balance(confirmed))
+                pending_out, pending_in = self._compute_pending_totals(pending, addr, current_height)
+                available_balance = max(0.0, total_balance - pending_out)
+
+                wallet_data = self.wallets.get(addr, {})
+                wallet_data["balance"] = total_balance
+                wallet_data["available_balance"] = available_balance
+                wallet_data["pending_out"] = pending_out
+                wallet_data["pending_in"] = pending_in
+
+                if addr == self.current_wallet_address:
+                    self.balance = total_balance
+                    self.available_balance = available_balance
+
+                updated[addr] = {
+                    "balance": total_balance,
+                    "available_balance": available_balance,
+                    "pending_out": pending_out,
+                    "pending_in": pending_in,
+                }
+
+            return updated
 
         except Exception as e:
             print(f"DEBUG: Error refreshing all wallet balances: {e}")
@@ -543,11 +637,12 @@ class LunaWallet:
             confirmed = self._confirmed_tx_cache.get(addr, [])
             pending = self._pending_tx_cache.get(addr, [])
 
+            # pending_in/pending_outはwallet_dataに格納済み
             overview[addr] = {
                 "balance": wallet_data.get("balance", 0.0),
                 "available_balance": wallet_data.get("available_balance", 0.0),
-                "pending_out": self._compute_pending_totals(pending, addr)[0],
-                "pending_in": self._compute_pending_totals(pending, addr)[1],
+                "pending_out": wallet_data.get("pending_out", 0.0),
+                "pending_in": wallet_data.get("pending_in", 0.0),
             }
 
             if include_transactions:

lunalib/core/wallet_db.py

@@ -1,64 +1,65 @@
-import sqlite3
-import os
-from cryptography.fernet import Fernet
-import hashlib
-import base64
-import json
-import time
+
+from lunalib.storage.database import WalletDatabase
+
 
 class WalletDB:
     def __init__(self, data_dir=None):
+        # data_dir is kept for compatibility, but db_path is passed to WalletDatabase
+        import os
         self.data_dir = data_dir or os.path.expanduser("~/.lunawallet")
         os.makedirs(self.data_dir, exist_ok=True)
         self.db_path = os.path.join(self.data_dir, "wallets.db")
-        self.conn = sqlite3.connect(self.db_path)
-        self._init_db()
-
-    def _init_db(self):
-        c = self.conn.cursor()
-        c.execute('''CREATE TABLE IF NOT EXISTS wallets (
-            address TEXT PRIMARY KEY,
-            label TEXT,
-            public_key TEXT,
-            encrypted_private_key BLOB,
-            is_locked INTEGER,
-            created REAL,
-            balance REAL,
-            available_balance REAL
-        )''')
-        self.conn.commit()
+        print(f"[WalletDB] data_dir: {self.data_dir}")
+        print(f"[WalletDB] db_path: {self.db_path}")
+        self.db = WalletDatabase(db_path=self.db_path)
 
     def save_wallet(self, address, label, public_key, encrypted_private_key, is_locked, created, balance, available_balance):
-        c = self.conn.cursor()
-        c.execute('''REPLACE INTO wallets (address, label, public_key, encrypted_private_key, is_locked, created, balance, available_balance)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?)''',
-            (address, label, public_key, encrypted_private_key, int(is_locked), created, balance, available_balance))
-        self.conn.commit()
+        # Compose wallet_data dict for WalletDatabase
+        wallet_data = {
+            'address': address,
+            'label': label,
+            'public_key': public_key,
+            'encrypted_private_key': encrypted_private_key,
+            'balance': balance,
+            'created': created,
+            'metadata': {'is_locked': bool(is_locked), 'available_balance': available_balance}
+        }
+        return self.db.save_wallet(wallet_data)
 
     def load_wallet(self, address):
-        c = self.conn.cursor()
-        c.execute('SELECT * FROM wallets WHERE address=?', (address,))
-        row = c.fetchone()
-        if row:
-            return {
-                'address': row[0],
-                'label': row[1],
-                'public_key': row[2],
-                'encrypted_private_key': row[3],
-                'is_locked': bool(row[4]),
-                'created': row[5],
-                'balance': row[6],
-                'available_balance': row[7],
-            }
-        return None
+        w = self.db.load_wallet(address)
+        if w:
+            # For compatibility, flatten metadata fields
+            meta = w.get('metadata', {})
+            w['is_locked'] = meta.get('is_locked', False)
+            w['available_balance'] = meta.get('available_balance', 0.0)
+        return w
 
     def list_wallets(self):
-        c = self.conn.cursor()
-        c.execute('SELECT address, label, is_locked, balance, available_balance FROM wallets')
-        return c.fetchall()
+        # Return list of tuples for compatibility: (address, label, is_locked, balance, available_balance)
+        import sqlite3
+        conn = sqlite3.connect(self.db_path)
+        cursor = conn.cursor()
+        cursor.execute('SELECT address, label, metadata, balance FROM wallets')
+        rows = cursor.fetchall()
+        conn.close()
+        result = []
+        for row in rows:
+            address, label, metadata_json, balance = row
+            meta = {}
+            try:
+                meta = json.loads(metadata_json) if metadata_json else {}
+            except Exception:
+                pass
+            is_locked = meta.get('is_locked', False)
+            available_balance = meta.get('available_balance', 0.0)
+            result.append((address, label, is_locked, balance, available_balance))
+        return result
+
 
     def close(self):
-        self.conn.close()
+        # No persistent connection to close in WalletDatabase
+        pass
 
 # Example usage:
 if __name__ == "__main__":

lunalib/tests/conftest.py

@@ -0,0 +1,41 @@
+import pytest
+import tempfile
+import os
+import time
+from lunalib.core.wallet import LunaWallet
+from lunalib.mining.miner import GenesisMiner
+from lunalib.gtx.genesis import GTXGenesis
+
+@pytest.fixture
+def temp_dir():
+    """Create temporary directory for test data"""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        yield tmpdir
+
+@pytest.fixture
+def test_wallet(temp_dir):
+    """Create a test wallet"""
+    wallet = LunaWallet(data_dir=temp_dir)
+    wallet_data = wallet.create_wallet("Test Wallet", "test_password")
+    return wallet, wallet_data
+
+@pytest.fixture
+def test_miner():
+    """Create a test miner"""
+    return GenesisMiner()
+
+@pytest.fixture
+def test_gtx(temp_dir):
+    """Create test GTX system"""
+    return GTXGenesis()
+
+@pytest.fixture
+def sample_transaction_data(test_wallet):
+    """Create sample transaction data"""
+    wallet, wallet_data = test_wallet
+    return {
+        "from": wallet_data["address"],
+        "to": "LUN_test_recipient_12345",
+        "amount": 100.0,
+        "memo": "Test transaction"
+    }

lunalib/tests/integration/test_integration.py

@@ -0,0 +1,62 @@
+import pytest
+import tempfile
+from lunalib.core.wallet import LunaWallet
+from lunalib.mining.miner import GenesisMiner
+from lunalib.gtx.genesis import GTXGenesis
+
+class TestIntegration:
+    def test_complete_workflow(self, temp_dir):
+        """Test complete wallet -> mining -> GTX workflow"""
+        # Create wallet
+        wallet = LunaWallet(data_dir=temp_dir)
+        wallet_data = wallet.create_wallet("Integration Test", "test_pass")
+
+        # Initialize systems
+        miner = GenesisMiner()
+        gtx = GTXGenesis()
+
+        # Mock mining a bill
+        with pytest.MonkeyPatch().context() as m:
+            m.setattr(miner, '_perform_mining', lambda *args: {
+                "success": True,
+                "hash": "000integration",
+                "nonce": 999,
+                "mining_time": 1.0
+            })
+
+            # Mine a bill
+            bill = miner.mine_bill(1000, wallet_data['address'])
+
+            assert bill['success'] is True
+            assert bill['denomination'] == 1000
+            assert bill['luna_value'] == 1000
+
+            # Create proper bill data for verification
+            metadata_hash = "test_metadata_hash_12345"
+            signature = metadata_hash  # This will pass METHOD 1 verification
+            
+            # Register the bill in GTX system for verification
+            bill_info = {
+                'bill_serial': bill['bill_serial'],
+                'denomination': 1000,
+                'user_address': wallet_data['address'],
+                'hash': "000integration",
+                'mining_time': 1.0,
+                'difficulty': 4,
+                'luna_value': 1000,
+                'timestamp': bill['timestamp'],
+                'bill_data': {
+                    'public_key': 'test_public_key',
+                    'signature': signature,  # Use the signature that matches metadata_hash
+                    'metadata_hash': metadata_hash,  # This must match signature for METHOD 1
+                    'issued_to': wallet_data['address'],
+                    'front_serial': bill['bill_serial'],
+                    'type': 'GTX_Genesis',
+                    'back_serial': ''  # Add this to avoid errors
+                }
+            }
+            gtx.bill_registry.register_bill(bill_info)
+
+            # Verify the bill
+            verification = gtx.verify_bill(bill['bill_serial'])
+            assert verification['valid'] is True

lunalib/tests/test_blockchain.py

@@ -0,0 +1,34 @@
+import pytest
+from unittest.mock import Mock, patch
+from lunalib.core.blockchain import BlockchainManager
+
+class TestBlockchain:
+    @patch('lunalib.core.blockchain.requests.get')
+    def test_blockchain_height(self, mock_get):
+        """Test blockchain height retrieval"""
+        mock_get.return_value.status_code = 200
+        mock_get.return_value.json.return_value = {'height': 1500}
+        
+        blockchain = BlockchainManager()
+        height = blockchain.get_blockchain_height()
+        
+        assert height == 1500
+
+    @patch('lunalib.core.blockchain.requests.get')
+    def test_network_connection(self, mock_get):
+        """Test network connection checking"""
+        mock_get.return_value.status_code = 200
+        
+        blockchain = BlockchainManager()
+        is_connected = blockchain.check_network_connection()
+        
+        assert is_connected is True
+
+    def test_transaction_scanning(self):
+        """Test transaction scanning functionality"""
+        blockchain = BlockchainManager()
+        
+        # This would typically be mocked in a real test
+        # For now, test the method exists and returns expected type
+        transactions = blockchain.scan_transactions_for_address("LUN_test", 0, 10)
+        assert isinstance(transactions, list)

lunalib/tests/test_crypto.py

@@ -0,0 +1,42 @@
+import pytest
+from lunalib.core.crypto import KeyManager
+
+class TestCrypto:
+    def test_key_generation(self):
+        """Test cryptographic key generation"""
+        key_manager = KeyManager()
+        
+        private_key = key_manager.generate_private_key()
+        public_key = key_manager.derive_public_key(private_key)
+        address = key_manager.derive_address(public_key)
+        
+        assert len(private_key) == 64  # 32 bytes in hex
+        assert len(public_key) == 64   # 32 bytes in hex
+        assert address.startswith("LUN_")
+
+    def test_data_signing(self):
+        """Test data signing and verification"""
+        key_manager = KeyManager()
+        
+        private_key = key_manager.generate_private_key()
+        public_key = key_manager.derive_public_key(private_key)
+        
+        test_data = "Hello, Luna Library!"
+        signature = key_manager.sign_data(test_data, private_key)
+        
+        # Basic signature format check
+        assert len(signature) == 64
+        assert all(c in "0123456789abcdef" for c in signature.lower())
+
+    def test_address_generation_uniqueness(self):
+        """Test that addresses are unique"""
+        key_manager = KeyManager()
+        
+        addresses = set()
+        for _ in range(10):
+            private_key = key_manager.generate_private_key()
+            public_key = key_manager.derive_public_key(private_key)
+            address = key_manager.derive_address(public_key)
+            addresses.add(address)
+        
+        assert len(addresses) == 10  # All addresses should be unique