checkpoint-sdk 0.1.0__py3-none-any.whl

checkpoint_sdk/__init__.py

@@ -0,0 +1,9 @@
+from .decoder.decoder import Decoder
+from .transaction.transaction import TransactionManager
+from .wallet.wallet import WalletManager
+
+__all__ = [
+    "Decoder",
+    "TransactionManager",
+    "WalletManager",
+]

checkpoint_sdk/decoder/decoder.py

@@ -0,0 +1,347 @@
+### --!-- --!-- --!-- better not to use python in Solana high performance production apps --!-- --!-- --!-- ###
+import requests
+from typing import Optional, Dict, Any, Tuple, List
+from checkpoint.decoder.exceptions import TooManyElements, NoElements
+import base64
+import struct
+
+class Decoder:
+    MAX = 6
+    IDLs = []
+
+    def __init__(self, programs):
+        programs_count = len(programs)
+
+        if programs_count > self.MAX:
+            raise TooManyElements(
+                f"Too many programs input! Max programs supported: {self.MAX} | Current input: {programs_count}"
+            )
+        elif programs_count == 0:
+            raise NoElements(
+                f"No programs on input! Expected MIN: 1 | MAX: {self.MAX} elements array"
+            )
+
+        for program_address in programs:
+            idl = self._fetch_idl(program_address)
+            self.IDLs.append(idl)
+    
+    def _find_idl(self, program_address: str):
+        for idl in self.IDLs:
+            idl_address = idl.get("address")
+            if idl_address and idl_address == program_address:
+                return idl
+    
+    def decode(self, base64_str: str, program_address: str):
+        """
+        Decodes input `Program data:` base64 string by program IDL
+        """
+        if not isinstance(base64_str, str): raise ValueError(f"Base 64 must be typeof string! Current type: {type(base64_str)} | decode()")
+        def normalize_b64(s: str) -> str:
+            s = s.strip().split()[-1]
+            return s + "=" * (-len(s) % 4)
+
+        idl = self._find_idl(program_address)
+        if not idl:
+            raise ValueError(f"IDL not found for program: {program_address}")
+            
+        events = idl.get("events", [])
+
+        b64_clean = normalize_b64(base64_str)
+        base64_raw = base64.b64decode(b64_clean)
+        discriminator = list(base64_raw[:8])
+
+        for event in events:
+            if event.get("discriminator") == discriminator:
+                name = event.get("name")
+                for _type in idl.get("types", []):
+                    if _type.get("name") == name:
+                        offset = 8
+                        result = {}
+                        if "type" in _type and "fields" in _type["type"]:
+                            for arg in _type["type"]["fields"]:
+                                val, offset = self._read_type(arg["type"], base64_raw, offset, idl)
+                                result[arg["name"]] = val
+                        return result
+        return None
+
+    def _read_primitive(self, t: str, data: bytes, offset: int) -> Tuple[Any, int]:
+        if t == "bool":
+            return data[offset] == 1, offset + 1
+
+        if t == "u8":
+            return data[offset], offset + 1
+        if t == "i8":
+            return struct.unpack_from("<b", data, offset)[0], offset + 1
+
+        if t == "u16":
+            return struct.unpack_from("<H", data, offset)[0], offset + 2
+        if t == "i16":
+            return struct.unpack_from("<h", data, offset)[0], offset + 2
+
+        if t == "u32":
+            return struct.unpack_from("<I", data, offset)[0], offset + 4
+        if t == "i32":
+            return struct.unpack_from("<i", data, offset)[0], offset + 4
+
+        if t == "u64":
+            return struct.unpack_from("<Q", data, offset)[0], offset + 8
+        if t == "i64":
+            return struct.unpack_from("<q", data, offset)[0], offset + 8
+
+        if t == "u128":
+            lo, hi = struct.unpack_from("<QQ", data, offset)
+            return (hi << 64) | lo, offset + 16
+
+        if t == "i128":
+            lo, hi = struct.unpack_from("<QQ", data, offset)
+            val = (hi << 64) | lo
+            if hi & (1 << 63):
+                val -= 1 << 128
+            return val, offset + 16
+
+        if t == "pubkey":
+            pubkey_bytes = data[offset:offset+32]
+            return self._bytes_to_base58(pubkey_bytes), offset + 32
+
+        raise ValueError(f"Unknown primitive type: {t}")
+
+    def _bytes_to_base58(self, data: bytes) -> str:
+        alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+        n = int.from_bytes(data, 'big')
+        result = ''
+        while n > 0:
+            n, remainder = divmod(n, 58)
+            result = alphabet[remainder] + result
+        
+        leading_zeros = 0
+        for byte in data:
+            if byte == 0:
+                leading_zeros += 1
+            else:
+                break
+        return '1' * leading_zeros + result
+
+    def _read_vec(self, inner, data, offset, idl):
+        length, offset = self._read_primitive("u32", data, offset)
+        items = []
+
+        for _ in range(length):
+            val, offset = self._read_type(inner, data, offset, idl)
+            items.append(val)
+
+        return items, offset
+
+    def _read_string(self, data, offset):
+        length, offset = self._read_primitive("u32", data, offset)
+        s = data[offset:offset+length].decode("utf-8")
+        return s, offset + length
+
+    def _read_bytes(self, data, offset):
+        length, offset = self._read_primitive("u32", data, offset)
+        return data[offset:offset+length], offset + length
+
+    def _read_defined(self, name: str, data: bytes, offset: int, idl):
+        type_def = None
+        for t in idl.get("types", []):
+            if t.get("name") == name:
+                type_def = t
+                break
+        
+        # if not type_def:
+        #     raise ValueError(f"Type definition not found: {name}")
+
+        kind = type_def["type"]["kind"]
+
+        if kind == "struct":
+            result = {}
+            for field in type_def["type"]["fields"]:
+                val, offset = self._read_type(field["type"], data, offset, idl)
+                result[field["name"]] = val
+            return result, offset
+
+        if kind == "enum":
+            discr, offset = self._read_primitive("u8", data, offset)
+            if discr >= len(type_def["type"]["variants"]):
+                raise ValueError(f"Invalid discriminator: {discr}")
+                
+            variant = type_def["type"]["variants"][discr]
+
+            if "fields" not in variant:
+                return variant["name"], offset
+
+            if isinstance(variant["fields"], list):
+                values = []
+                for f in variant["fields"]:
+                    if isinstance(f, dict):
+                        val, offset = self._read_type(f.get("type", f), data, offset, idl)
+                    else:
+                        val, offset = self._read_type(f, data, offset, idl)
+                    values.append(val)
+                return {variant["name"]: values}, offset
+            else:
+                obj = {}
+                for f in variant["fields"]:
+                    val, offset = self._read_type(f["type"], data, offset, idl)
+                    obj[f["name"]] = val
+                return {variant["name"]: obj}, offset
+
+    def _read_type(self, t, data: bytes, offset: int, idl):
+        if isinstance(t, str):
+            if t == "string":
+                return self._read_string(data, offset)
+            if t == "bytes":
+                return self._read_bytes(data, offset)
+            return self._read_primitive(t, data, offset)
+
+        if isinstance(t, dict):
+
+            if t.get("kind") == "struct":
+                result = {}
+                for field in t.get("fields", []):
+                    val, offset = self._read_type(field["type"], data, offset, idl)
+                    result[field["name"]] = val
+                return result, offset
+
+            if t.get("kind") == "enum":
+                discr, offset = self._read_primitive("u8", data, offset)
+                variant = t["variants"][discr]
+
+                if "fields" not in variant:
+                    return variant["name"], offset
+
+                values = {}
+                for f in variant.get("fields", []):
+                    val, offset = self._read_type(f["type"], data, offset, idl)
+                    values[f["name"]] = val
+
+                return {variant["name"]: values}, offset
+
+            if "option" in t:
+                flag, offset = self._read_primitive("u8", data, offset)
+                if flag == 0:
+                    return None, offset
+                return self._read_type(t["option"], data, offset, idl)
+
+            if "vec" in t:
+                return self._read_vec(t["vec"], data, offset, idl)
+
+            if "array" in t:
+                inner, size = t["array"]
+                arr = []
+                for _ in range(size):
+                    val, offset = self._read_type(inner, data, offset, idl)
+                    arr.append(val)
+                return arr, offset
+
+            if "defined" in t:
+                return self._read_defined(t["defined"], data, offset, idl)
+
+        raise ValueError(f"Unknown IDL type: {t}")
+
+    def extract_program_data(self, tx: Dict, program_address: str) -> Optional[str]:
+        """
+        This function only works in some cases!!!
+        Be care using it, not always we can find correct str, so in most cases you need to find base64 data at your own
+        """
+        params = tx.get("params")
+        if not params:
+            return None
+
+        results = params.get("result")
+        if not results:
+            return None
+
+        value = results.get("value")
+        if not value:
+            return None
+        
+        logs = value.get("logs")
+        if not isinstance(logs, list):
+            return None
+
+        for i in range(len(logs) - 1):
+            line = logs[i]
+            next_line = logs[i + 1]
+
+            if (
+                isinstance(line, str)
+                and line.startswith("Program data:")
+                and isinstance(next_line, str)
+                and next_line.startswith(f"Program {program_address} invoke")
+            ):
+                return line.replace("Program data:", "").strip()
+
+        return None
+
+    def decode_on_demand(self, tx, program_id):
+        """
+        Automatically extracts first entry `Program data:` of set program address and returns decoded data
+        """
+        data = self.extract_program_data(tx, program_id)
+        return self.decode(data, program_id) if data else None
+
+    def extract_all_program_data(self, tx):
+        """
+        Extracts all `Program data:` strings from tx, so you can use it to `unsafe` parse all your strings using batch_decode()
+        """
+        result = []
+        params = tx.get("params")
+        if not params:
+            return None
+
+        results = params.get("result")
+        if not results:
+            return None
+
+        value = results.get("value")
+        if not value:
+            return None
+        
+        logs = value.get("logs")
+        if not isinstance(logs, list):
+            return None
+
+        for i in range(len(logs) - 1):
+            line = logs[i]
+
+            if (
+                isinstance(line, str)
+                and line.startswith("Program data:")
+            ):
+                result.append(line.replace("Program data:", "").strip())
+
+        return result
+
+    def batch_decode(self, extract_all_program_data_result: list, program_address: str) -> Optional[List[dict]]:
+        results = {}
+        for data in extract_all_program_data_result:
+            results[data[:10]] = self.decode(data, program_address)
+        return results
+
+    def _fetch_idl(self, program_address: str) -> Optional[Dict[str, Any]]:
+        url = f"https://api-v2.solscan.io/v2/account/anchor_idl?address={program_address}"
+
+        headers = {
+            "User-Agent": "Mozilla/5.0 (X11; Linux x86_64; rv:145.0) Gecko/20100101 Firefox/145.0",
+            "Accept": "application/json, text/plain, */*",
+            "Origin": "https://solscan.io",
+            "Referer": "https://solscan.io/",
+        }
+
+        try:
+            response = requests.get(
+                url,
+                headers=headers,
+                timeout=30
+            )
+
+            response.raise_for_status()
+            data = response.json()
+
+            if data.get("success"):
+                return data.get("data")
+
+            return None
+
+        except Exception as e:
+            raise Exception(f"Error fetching IDL for {program_address}: {e}")

checkpoint_sdk/decoder/exceptions.py

@@ -0,0 +1,8 @@
+class TooManyElements(Exception):
+    pass
+
+class NoElements(Exception):
+    pass
+
+class NoIDLMatch(Exception):
+    pass

checkpoint_sdk/transaction/exceptions.py

@@ -0,0 +1,17 @@
+class EncodingNotSupported(Exception):
+    pass
+
+class TransactionError(Exception):
+    pass
+
+class TransactionTimeoutError(TransactionError):
+    pass
+
+class TransactionNotFoundError(TransactionError):
+    pass
+
+class RPCConnectionError(TransactionError):
+    pass
+
+class InvalidTransactionError(TransactionError):
+    pass

checkpoint_sdk/transaction/transaction.py

@@ -0,0 +1,289 @@
+from typing import Optional, List, Dict, Any, Union
+import requests
+import json
+from datetime import datetime
+from dataclasses import dataclass
+from enum import Enum
+from checkpoint.transaction.exceptions import *
+
+class TransactionStatus(str, Enum):
+    CONFIRMED = "confirmed"
+    FINALIZED = "finalized"
+    PROCESSED = "processed"
+
+class TransactionEncoding(str, Enum):
+    BASE64 = "base64"
+    BASE58 = "base58"
+    JSON_PARSED = "jsonParsed"
+
+@dataclass
+class TransactionConfig:
+    encoding: TransactionEncoding = TransactionEncoding.JSON_PARSED
+    commitment: TransactionStatus = TransactionStatus.CONFIRMED
+    max_supported_transaction_version: int = 0
+    timeout: int = 30
+
+class TransactionManager:
+    def __init__(
+        self,
+        rpc_url: str = "https://api.mainnet-beta.solana.com",
+        headers: Optional[Dict[str, str]] = None,
+        config: Optional[TransactionConfig] = None
+    ):
+        self.rpc_url = rpc_url
+        self.headers = headers or {"Content-Type": "application/json"}
+        self.config = config or TransactionConfig()
+        self.session = requests.Session()
+
+        if self.headers:
+            self.session.headers.update(self.headers)
+
+    def _validate_encoding(self, encoding: str) -> None:
+        if encoding not in [e.value for e in TransactionEncoding]:
+            available = ", ".join([e.value for e in TransactionEncoding])
+            raise EncodingNotSupported(
+                f"Encoding '{encoding}' not supported. Available: {available}"
+            )
+
+    def _make_request(self, method: str, params: List[Any]) -> Dict[str, Any]:
+        payload = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": method,
+            "params": params
+        }
+
+        try:
+            response = self.session.post(
+                self.rpc_url,
+                json=payload,
+                timeout=self.config.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.Timeout as e:
+            raise TransactionTimeoutError(f"Request timeout exceeded: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            raise RPCConnectionError(f"RPC connection error: {str(e)}")
+        except Exception as e:
+            raise RPCConnectionError(f"Unexpected error: {str(e)}")
+
+    def get_transaction(
+        self,
+        signature: str,
+        encoding: Optional[str] = None,
+        commitment: Optional[str] = None
+    ) -> Dict[str, Any]:
+        encoding = encoding or self.config.encoding.value
+        commitment = commitment or self.config.commitment.value
+
+        self._validate_encoding(encoding)
+
+        params = [
+            signature,
+            {
+                "encoding": encoding,
+                "commitment": commitment,
+                "maxSupportedTransactionVersion": self.config.max_supported_transaction_version
+            }
+        ]
+
+        return self._make_request("getTransaction", params)
+
+    def get_transaction_batch(
+        self,
+        signatures: List[str],
+        encoding: Optional[str] = None,
+        commitment: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        encoding = encoding or self.config.encoding.value
+        commitment = commitment or self.config.commitment.value
+
+        self._validate_encoding(encoding)
+
+        payload = [
+            {
+                "jsonrpc": "2.0",
+                "id": i,
+                "method": "getTransaction",
+                "params": [
+                    sig,
+                    {
+                        "encoding": encoding,
+                        "commitment": commitment,
+                        "maxSupportedTransactionVersion": self.config.max_supported_transaction_version
+                    }
+                ]
+            }
+            for i, sig in enumerate(signatures)
+        ]
+
+        try:
+            response = self.session.post(
+                self.rpc_url,
+                json=payload,
+                timeout=self.config.timeout
+            )
+            response.raise_for_status()
+            return response.json()
+        except requests.exceptions.RequestException as e:
+            raise RPCConnectionError(f"Batch request failed: {str(e)}")
+
+    def get_signatures_for_address(
+        self,
+        address: str,
+        limit: int = 1000,
+        before: Optional[str] = None,
+        until: Optional[str] = None,
+        commitment: Optional[str] = None
+    ) -> Dict[str, Any]:
+        commitment = commitment or self.config.commitment.value
+
+        params = [address]
+        options = {"limit": limit}
+
+        if before:
+            options["before"] = before
+        if until:
+            options["until"] = until
+
+        if options:
+            params.append(options)
+
+        return self._make_request("getSignaturesForAddress", params)
+
+    def get_transaction_history(
+        self,
+        address: str,
+        limit: int = 10,
+        encoding: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        signatures_response = self.get_signatures_for_address(address, limit=limit)
+
+        if "error" in signatures_response:
+            return []
+
+        signatures = [sig["signature"] for sig in signatures_response.get("result", [])]
+
+        return self.get_transaction_batch(signatures, encoding=encoding)
+
+    def get_latest_blockhash(
+        self,
+        commitment: Optional[str] = None
+    ) -> Dict[str, Any]:
+        commitment = commitment or self.config.commitment.value
+
+        return self._make_request("getLatestBlockhash", [{"commitment": commitment}])
+
+    def confirm_transaction(
+        self,
+        signature: str,
+        commitment: Optional[str] = None,
+        timeout: int = 30,
+        poll_interval: int = 1
+    ) -> bool:
+        import time
+
+        commitment = commitment or self.config.commitment.value
+        end_time = time.time() + timeout
+
+        while time.time() < end_time:
+            try:
+                result = self.get_transaction(signature, commitment=commitment)
+
+                if result.get("result") is not None:
+                    return True
+
+                time.sleep(poll_interval)
+            except Exception:
+                time.sleep(poll_interval)
+
+        return False
+
+    def parse_transaction_data(
+        self,
+        transaction_data: Dict[str, Any],
+        format_output: bool = False
+    ) -> Union[Dict[str, Any], str]:
+
+        if "error" in transaction_data:
+            return transaction_data
+
+        result = transaction_data.get("result", {})
+
+        if not format_output:
+            return result
+
+        parsed = {
+            "signature": result.get("transaction", {}).get("signatures", [""])[0],
+            "slot": result.get("slot"),
+            "block_time": datetime.fromtimestamp(result.get("blockTime", 0))
+                        if result.get("blockTime") else None,
+            "fee": result.get("meta", {}).get("fee"),
+            "status": "Success" if result.get("meta", {}).get("err") is None else "Failed",
+            "instructions_count": len(result.get("transaction", {}).get("message", {}).get("instructions", []))
+        }
+
+        return parsed
+
+    def simulate_transaction(
+        self,
+        transaction_data: str,
+        commitment: Optional[str] = None
+    ) -> Dict[str, Any]:
+        commitment = commitment or self.config.commitment.value
+
+        params = [
+            transaction_data,
+            {
+                "encoding": "base64",
+                "commitment": commitment
+            }
+        ]
+
+        return self._make_request("simulateTransaction", params)
+
+    def get_transaction_cost(
+        self,
+        transaction_data: str
+    ) -> Dict[str, Any]:
+        simulation = self.simulate_transaction(transaction_data)
+
+        if "error" in simulation:
+            return {"error": simulation["error"]}
+
+        result = simulation.get("result", {})
+
+        return {
+            "compute_units_consumed": result.get("unitsConsumed"),
+            "fee": result.get("fee"),
+            "logs": result.get("logs", [])
+        }
+
+    def get_program_accounts(
+        self,
+        program_id: str,
+        encoding: Optional[str] = None,
+        commitment: Optional[str] = None
+    ) -> Dict[str, Any]:
+        encoding = encoding or self.config.encoding.value
+        commitment = commitment or self.config.commitment.value
+
+        params = [
+            program_id,
+            {
+                "encoding": encoding,
+                "commitment": commitment
+            }
+        ]
+
+        return self._make_request("getProgramAccounts", params)
+
+    def close(self):
+        self.session.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

checkpoint_sdk/wallet/exceptions.py

@@ -0,0 +1,2 @@
+class InsufficientBalance(Exception):
+    pass

checkpoint_sdk/wallet/wallet.py

@@ -0,0 +1,224 @@
+from solders.pubkey import Pubkey
+from solders.keypair import Keypair
+from solders.system_program import TransferParams, transfer
+from solana.rpc.api import Client
+from solders.transaction import Transaction
+import base58
+from typing import Dict, Optional, Union
+from checkpoint.wallet.exceptions import InsufficientBalance
+
+class TransferConfig:
+    def __init__(self, fixed_fee_lamports: int = 0, min_amount_lamports: int = 0, 
+                 max_amount_lamports: int = 2**63-1, enabled: bool = True):
+        self.fixed_fee_lamports = fixed_fee_lamports
+        self.min_amount_lamports = min_amount_lamports
+        self.max_amount_lamports = max_amount_lamports
+        self.enabled = enabled
+
+class WalletManager:
+    def __init__(self, rpc_url: str = "https://api.mainnet-beta.solana.com", base_wallet_keypair: Optional[Keypair] = None):
+        self.client = Client(rpc_url)
+        self.wallets: Dict[str, Keypair] = {}
+        self.transfer_config = TransferConfig()
+        self.transaction_history = []
+        
+        if base_wallet_keypair:
+            self.base_wallet = base_wallet_keypair
+            wallet_id = str(base_wallet_keypair.pubkey())
+            self.wallets[wallet_id] = base_wallet_keypair
+        else:
+            self.base_wallet = Keypair()
+            wallet_id = str(self.base_wallet.pubkey())
+            self.wallets[wallet_id] = self.base_wallet
+    
+    def create_wallet(self) -> str:
+        new_keypair = Keypair()
+        wallet_id = str(new_keypair.pubkey())
+        self.wallets[wallet_id] = new_keypair
+        return wallet_id
+    
+    def import_wallet_from_private_key(self, private_key_base58: str) -> str:
+        secret_key = base58.b58decode(private_key_base58)
+        keypair = Keypair.from_bytes(secret_key)
+        wallet_id = str(keypair.pubkey())
+        self.wallets[wallet_id] = keypair
+        return wallet_id
+    
+    def get_balance(self, wallet_id: str) -> int:
+        if wallet_id not in self.wallets:
+            raise ValueError(f"Wallet not found")
+        
+        pubkey = Pubkey.from_string(wallet_id)
+        response = self.client.get_balance(pubkey)
+        return response.value
+    
+    def get_balance_sol(self, wallet_id: str) -> float:
+        lamports = self.get_balance(wallet_id)
+        return lamports / 1_000_000_000
+    
+    def set_transfer_config(self, fixed_fee_sol: float = 0.0, min_amount_sol: float = 0.0,
+                           max_amount_sol: float = float('inf'), enabled: bool = True):
+        fixed_fee_lamports = int(fixed_fee_sol * 1_000_000_000)
+        min_amount_lamports = int(min_amount_sol * 1_000_000_000)
+        max_amount_lamports = int(max_amount_sol * 1_000_000_000) if max_amount_sol != float('inf') else 2**63-1
+        
+        self.transfer_config = TransferConfig(fixed_fee_lamports, min_amount_lamports, max_amount_lamports, enabled)
+    
+    def transfer(self, from_wallet_id: str, to_wallet_id: str, amount_sol: float,
+                use_config: bool = False, custom_config: Optional[TransferConfig] = None) -> str:
+        if from_wallet_id not in self.wallets:
+            raise ValueError(f"Sender wallet not found")
+        
+        from_keypair = self.wallets[from_wallet_id]
+        to_pubkey = Pubkey.from_string(to_wallet_id)
+        
+        amount_lamports = int(amount_sol * 1_000_000_000)
+        
+        config = None
+        if use_config:
+            config = custom_config if custom_config else self.transfer_config
+        
+        if config and config.enabled:
+            if amount_lamports < config.min_amount_lamports:
+                raise ValueError(f"Transfer amount too small")
+            if amount_lamports > config.max_amount_lamports:
+                raise ValueError(f"Transfer amount too large")
+        
+        fee_lamports = config.fixed_fee_lamports if config and config.enabled else 0
+        total_lamports = amount_lamports + fee_lamports
+        
+        balance = self.get_balance(from_wallet_id)
+        if balance < total_lamports:
+            raise InsufficientBalance(f"Insufficient SOL balance")
+        
+        transaction = Transaction()
+        transaction.add(
+            transfer(
+                TransferParams(
+                    from_pubkey=from_keypair.pubkey(),
+                    to_pubkey=to_pubkey,
+                    lamports=amount_lamports
+                )
+            )
+        )
+        
+        if fee_lamports > 0:
+            fee_receiver = Pubkey.from_string("11111111111111111111111111111111")
+            transaction.add(
+                transfer(
+                    TransferParams(
+                        from_pubkey=from_keypair.pubkey(),
+                        to_pubkey=fee_receiver,
+                        lamports=fee_lamports
+                    )
+                )
+            )
+        
+        result = self.client.send_transaction(transaction, from_keypair)
+        signature = str(result.value)
+        
+        transaction_record = {
+            'from': from_wallet_id,
+            'to': to_wallet_id,
+            'amount_sol': amount_sol,
+            'amount_lamports': amount_lamports,
+            'fee_sol': fee_lamports / 1_000_000_000,
+            'fee_lamports': fee_lamports,
+            'signature': signature,
+            'timestamp': self._get_timestamp()
+        }
+        self.transaction_history.append(transaction_record)
+        
+        return signature
+    
+    def instant_transfer(self, from_wallet_id: str, to_wallet_id: str, amount_sol: float,
+                        use_config: bool = False, custom_config: Optional[TransferConfig] = None) -> Dict:
+        try:
+            signature = self.transfer(from_wallet_id, to_wallet_id, amount_sol, use_config, custom_config)
+            
+            from_balance = self.get_balance_sol(from_wallet_id)
+            to_balance = self.get_balance_sol(to_wallet_id)
+            
+            result = {
+                'status': 'success',
+                'signature': signature,
+                'explorer_url': f"https://solscan.io/tx/{signature}",
+                'from_wallet': from_wallet_id,
+                'to_wallet': to_wallet_id,
+                'amount_sol': amount_sol,
+                'from_balance_sol': from_balance,
+                'to_balance_sol': to_balance
+            }
+            
+            return result
+            
+        except (InsufficientBalance, ValueError) as e:
+            result = {
+                'status': 'error',
+                'message': str(e),
+                'from_wallet': from_wallet_id,
+                'to_wallet': to_wallet_id
+            }
+            return result
+    
+    def airdrop(self, wallet_id: str, amount_sol: float = 1.0) -> str:
+        if wallet_id not in self.wallets:
+            raise ValueError(f"Wallet not found")
+        
+        pubkey = Pubkey.from_string(wallet_id)
+        amount_lamports = int(amount_sol * 1_000_000_000)
+        
+        result = self.client.request_airdrop(pubkey, amount_lamports)
+        return str(result.value)
+    
+    def get_recent_blockhash(self) -> str:
+        response = self.client.get_recent_blockhash()
+        return str(response.value.blockhash)
+    
+    def estimate_transfer_fee(self, amount_sol: float, use_config: bool = False) -> float:
+        amount_lamports = int(amount_sol * 1_000_000_000)
+        
+        config = None
+        if use_config:
+            config = self.transfer_config
+        
+        fee_lamports = config.fixed_fee_lamports if config and config.enabled else 0
+        
+        response = self.client.get_fee_for_message(self.client.get_recent_blockhash().value.blockhash)
+        priority_fee = response.value or 0
+        
+        total_fee_lamports = fee_lamports + priority_fee
+        return total_fee_lamports / 1_000_000_000
+    
+    def get_wallet_private_key(self, wallet_id: str) -> str:
+        if wallet_id not in self.wallets:
+            raise ValueError(f"Wallet not found")
+        
+        keypair = self.wallets[wallet_id]
+        return base58.b58encode(bytes(keypair)).decode('utf-8')
+    
+    def get_wallet_public_key(self, wallet_id: str) -> str:
+        if wallet_id not in self.wallets:
+            raise ValueError(f"Wallet not found")
+        
+        return wallet_id
+    
+    def get_transaction_history(self, wallet_id: Optional[str] = None) -> list:
+        if wallet_id:
+            return [t for t in self.transaction_history 
+                   if t['from'] == wallet_id or t['to'] == wallet_id]
+        return self.transaction_history
+    
+    def _get_timestamp(self) -> str:
+        from datetime import datetime
+        return datetime.now().isoformat()
+    
+    def get_network_info(self) -> Dict:
+        version = self.client.get_version()
+        slot = self.client.get_slot()
+        
+        return {
+            'network': str(self.client._provider.endpoint_uri),
+            'solana_version': str(version.value),
+            'current_slot': slot.value
+        }

checkpoint_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: checkpoint-sdk
+Version: 0.1.0
+Summary: Program-agnostic Solana IDL transaction decoder and SDK
+Author: apchhui
+License: MIT
+Project-URL: Homepage, https://github.com/apchhui/checkpoint-sdk
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.31.0
+Requires-Dist: solana>=0.30.0
+Requires-Dist: solders>=0.19.0
+Requires-Dist: base58>=2.1.1
+Dynamic: license-file
+
+# checkpoint-sdk
+
+Solana SDK for:
+- Real-time transaction decoding via Anchor IDL
+- Program-agnostic decoding
+- Batch RPC fetching
+- Wallet utilities
+etc.
+
+## Install
+
+```bash
+pip install checkpoint-sdk

checkpoint_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+checkpoint_sdk/__init__.py,sha256=IBWcv9CmWNz-58jUzJ2Kw-8PFfziTwVmnU9kJAwCH2Y,211
+checkpoint_sdk/decoder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+checkpoint_sdk/decoder/decoder.py,sha256=LRhQVpmJGhp9JV9e_UiWlFFufkVtbU_ykr7uD7xkix8,12234
+checkpoint_sdk/decoder/exceptions.py,sha256=_79SdYcipOtARlma6xxbyevoBSLD5gsStfqmv3-sCp8,120
+checkpoint_sdk/transaction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+checkpoint_sdk/transaction/exceptions.py,sha256=-xvU_x5sbZmqSlws5tzco4To8a8IY9m2hJakQ4ya4oQ,324
+checkpoint_sdk/transaction/transaction.py,sha256=K7KW40ws5eGLWiCYlMWhDbVGErDSZqqawwBjK9FoYS4,8807
+checkpoint_sdk/wallet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+checkpoint_sdk/wallet/exceptions.py,sha256=OKUjDRUrTAaboyipffMbtgrBveTXQ-7Hs1RLDS1AXkU,46
+checkpoint_sdk/wallet/wallet.py,sha256=uDKYybYkI3InuqdIO5K0wFEb72YMiJpb0_4UOSZMV6Y,8939
+checkpoint_sdk-0.1.0.dist-info/licenses/LICENSE,sha256=sj7YvNopsXtWmDnVHfpLIDLW4GepOVBTz_7ZmPzs1y0,1064
+checkpoint_sdk-0.1.0.dist-info/METADATA,sha256=IizF-exI8AY595owFo5vk5PZ1IQJLa8IljXiz9cZxPo,651
+checkpoint_sdk-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+checkpoint_sdk-0.1.0.dist-info/top_level.txt,sha256=nh91TPgvkL3xy4qPQRZ3FYRXryJR_U8wDbBal86_4yk,15
+checkpoint_sdk-0.1.0.dist-info/RECORD,,

checkpoint_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

checkpoint_sdk-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 apchhui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

checkpoint_sdk-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+checkpoint_sdk