shadowPaySDK 0.1.0__py3-none-any.whl → 0.1__py3-none-any.whl

shadowPaySDK/interface/erc20.py

@@ -1,74 +1,85 @@
+import shadowPaySDK
 from web3 import Web3
 import json
 from typing import Union, Optional
-
-ERC20_ABI = json.loads("""[
-    {"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"type":"function"},
-    {"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"type":"function"},
-    {"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"type":"function"},
-    {"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"type":"function"},
-    {"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"type":"function"},
-    {"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"","type":"bool"}],"type":"function"},
-    {"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"","type":"bool"}],"type":"function"},
-    {"constant":true,"inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"type":"function"},
-    {"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"","type":"bool"}],"type":"function"}
-]""")
+from shadowPaySDK.const import __ERC20_ABI__
 
 
 class ERC20Token:
-    def __init__(self, web3: Web3, token: str, explorer: Optional[str] = None):
-        self.web3 = web3
+    def __init__(self,  w3: Optional[Web3] = None, explorer: Optional[str] = None):
+        self.web3 = w3
         self.explorer = explorer
-        self.address = Web3.to_checksum_address(token)
-        self.contract = web3.eth.contract(address=self.address, abi=ERC20_ABI)
+
+        self.address = None
+        self.contract = None
+
+    def set_params(self, token_address: Optional[str] = None, w3:Optional[Web3] = None):
+        if w3:
+            self.web3 = w3
+        if token_address:
+            self.address = Web3.to_checksum_address(token_address)
+            self.contract = self.web3.eth.contract(address=self.address, abi=__ERC20_ABI__)
+
+    def _ensure_contract(self):
+        if not self.contract:
+            raise ValueError("Token address is not set. Use set_params first.")
 
     def _format_tx(self, tx_hash: str) -> str:
         if self.explorer:
             return f"{self.explorer.rstrip('/')}/tx/{tx_hash}"
         return tx_hash
-
-
-
+    def gen_wallet(self) -> str:
+        account = self.web3.eth.account.create()
+        return account
     def get_decimals(self) -> int:
+        self._ensure_contract()
+
         return self.contract.functions.decimals().call()
 
     def get_symbol(self) -> str:
+        self._ensure_contract()
         return self.contract.functions.symbol().call()
 
     def get_balance(self, wallet_address: str) -> float:
-        raw_balance = self.contract.functions.balanceOf(
-            Web3.to_checksum_address(wallet_address)
-        ).call()
-        return raw_balance / (10 ** self.get_decimals())
-
+        self._ensure_contract()
+        raw = self.contract.functions.balanceOf(Web3.to_checksum_address(wallet_address)).call()
+        return raw 
 
 
     def allowance(self, owner: str, spender: str) -> float:
+        self._ensure_contract()
         raw = self.contract.functions.allowance(
             Web3.to_checksum_address(owner),
             Web3.to_checksum_address(spender)
         ).call()
-        return raw / (10 ** self.get_decimals())
+        return raw 
 
-    def ensure_allowance(self, private_key: str, spender: str, amount: float) -> Union[bool, str]:
+    def ensure_allowance(self, private_key: str, spender: str, amount, converted_amount: bool = False) -> Union[bool, str]:
+        self._ensure_contract()
         account = self.web3.eth.account.from_key(private_key)
-        current_allowance = self.allowance(account.address, spender)
-        if current_allowance >= amount:
+        current = self.allowance(account.address, spender)
+        if current == amount:
             return True
-        return self.approve(private_key, spender, amount)
-    
+        return self.approve(private_key, spender, amount, conveted_amount=converted_amount)
+
     def transfer(self, private_key: str, to: str, amount: float) -> str:
+        self._ensure_contract()
         account = self.web3.eth.account.from_key(private_key)
-        decimals = self.get_decimals()
-        value = int(amount * (10 ** decimals))
-
+        
+        estimated_gas = self.contract.functions.transfer(
+            Web3.to_checksum_address(to),
+            amount
+        ).estimate_gas({
+            'from': account.address,
+            'gasPrice': self.web3.to_wei('5', 'gwei'),
+        })
         txn = self.contract.functions.transfer(
             Web3.to_checksum_address(to),
-            value
+            amount
         ).build_transaction({
             'from': account.address,
             'nonce': self.web3.eth.get_transaction_count(account.address),
-            'gas': 100_000,
+            'gas': estimated_gas,
             'gasPrice': self.web3.to_wei('5', 'gwei'),
         })
 
@@ -76,27 +87,34 @@ class ERC20Token:
         tx_hash = self.web3.eth.send_raw_transaction(signed.raw_transaction)
         return self._format_tx(self.web3.to_hex(tx_hash))
 
-    def approve(self, private_key: str, spender: str, amount: float) -> str:
-        account = self.web3.eth.account.from_key(private_key)
-        decimals = self.get_decimals()
-        value = int(amount * (10 ** decimals))
-
+    def approve(self,  spender: str, amount: float,address:Optional[str] = None,  private_key: Optional[str] = None, conveted_amount: bool = True) -> str:
+        
+        self._ensure_contract()
+        key = private_key
+
+        if key:
+            address = Web3.to_checksum_address(self.web3.eth.account.from_key(key).address)
+        
+        elif self.address:
+            address = Web3.to_checksum_address(self.address)
+        else:
+            raise ValueError("No private key or address provided")
         txn = self.contract.functions.approve(
             Web3.to_checksum_address(spender),
-            value
+            amount
         ).build_transaction({
-            'from': account.address,
-            'nonce': self.web3.eth.get_transaction_count(account.address),
-            'gas': 100_000,
-            'gasPrice': self.web3.to_wei('5', 'gwei'),
+            'from': address,
+            'nonce': self.web3.eth.get_transaction_count(address),
+            'gas': 60000,
+            
+            'gasPrice': self.web3.eth.gas_price,
         })
+        
 
-        signed = self.web3.eth.account.sign_transaction(txn, private_key)
+        signed = self.web3.eth.account.sign_transaction(txn, key)
         tx_hash = self.web3.eth.send_raw_transaction(signed.raw_transaction)
-        return self._format_tx(self.web3.to_hex(tx_hash))
-
-
-
-
-
+        tx_receipt = self.web3.eth.wait_for_transaction_receipt(tx_hash)
+        if tx_receipt.status != 1:
+            raise ValueError(f"aaprove fail.\n {self._format_tx(self.web3.to_hex(tx_hash))}")
+        return f"{self._format_tx(self.web3.to_hex(tx_hash))}"
 

shadowPaySDK/interface/sol.py

@@ -0,0 +1,225 @@
+import asyncio
+import solana
+from solana.rpc.async_api import AsyncClient, GetTokenAccountsByOwnerResp
+from solders.transaction import Transaction
+from solders.system_program import TransferParams as p
+import spl
+import spl.token
+import spl.token.constants
+from spl.token.instructions import get_associated_token_address, create_associated_token_account, transfer, close_account, TransferParams
+from solders.system_program import transfer as ts
+from solders.system_program import TransferParams as tsf
+from spl.token.constants import TOKEN_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID
+from solana.rpc.types import TxOpts, TokenAccountOpts
+from solana.rpc.types import TxOpts
+import solders
+from solders.message import Message
+
+# from solders.pubkey import Pubkey
+# from solders.keypair import Keypair
+# from solders.signature import Signature
+# from solders.transaction import Transaction
+from spl.token.async_client import AsyncToken
+
+
+from solana.rpc.commitment import Confirmed
+from solana.rpc.async_api import AsyncClient
+import anchorpy
+from anchorpy import Provider, Wallet, Idl
+from typing import Optional, Union
+import pprint
+import httpx
+import base64
+import re
+
+
+LAMPORTS_PER_SOL = 1_000_000_000  # 1 SOL = 1,000,000,000 lamports
+
+class SOL:
+    def __init__(self, rpc_url = "https://api.mainnet-beta.solana.com", KEYPAIR: Optional[Union[str, solders.keypair.Keypair]] = None,TOKEN_MINT: Optional[str] = None):
+            self.rpc_url = rpc_url
+    
+            self.client = AsyncClient(rpc_url)
+            self.KEYPAIR = None
+            self.PROGRAM_ID = TOKEN_PROGRAM_ID # Default to the SPL Token Program ID
+            self.TOKEN_MINT = TOKEN_MINT
+            self.WRAPED_SOL_ID = spl.token.constants.WRAPPED_SOL_MINT
+            if KEYPAIR:
+                self.set_keypair(KEYPAIR)
+
+    def set_keypair(self, KEYPAIR: Union[str, solders.keypair.Keypair]):
+        if isinstance(KEYPAIR, str):
+            try:
+                self.KEYPAIR = solders.keypair.Keypair.from_base58_string(KEYPAIR)
+            except Exception as e:
+                raise ValueError(f"Invalid Keypair string: {e}")
+        elif isinstance(KEYPAIR, solders.keypair.Keypair):
+            self.KEYPAIR = KEYPAIR
+        else:
+            raise ValueError("KEYPAIR must be a Keypair instance or a base58 encoded string.")
+
+    def set_params(self, rpc_url: Optional[str] = None, KEYPAIR: Optional[Union[str, solders.keypair.Keypair]] = None,TOKEN_MINT: Optional[str] = None):
+        if rpc_url:
+            self.rpc_url = rpc_url
+            self.client = AsyncClient(rpc_url)
+        if KEYPAIR:
+            self.set_keypair(KEYPAIR)            
+        if TOKEN_MINT:
+            self.TOKEN_MINT = TOKEN_MINT
+
+    def get_pubkey(self, returnString: Optional[bool] = None):
+
+        
+        if self.KEYPAIR:
+            pubkey = self.KEYPAIR.pubkey()
+            pubkey_str = str(pubkey)
+            if returnString:
+                return pubkey_str
+            return pubkey
+        
+        raise ValueError("Keypair not set")
+
+    def gen_wallet(self):
+        return solders.keypair.Keypair()
+    async def get_balance(self):
+        resp = await self.client.get_balance(self.get_pubkey())
+        lamports = resp.value
+        sol_balance = lamports / LAMPORTS_PER_SOL
+        return sol_balance  
+    async def get_token_accounts_by_owner(self,owner_pubkey: Optional[str] = None):
+        if not owner_pubkey:
+            print("No owner pubkey provided, using the wallet's pubkey.")
+            owner_pubkey = self.get_pubkey(returnString=True)
+        headers = {
+            "Content-Type": "application/json",
+        }
+        body = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "getTokenAccountsByOwner",
+            "params": [
+                str(owner_pubkey),
+                {"programId": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"},
+                {"encoding": "jsonParsed"}
+            ]
+        }
+        async with httpx.AsyncClient() as client:
+            response = await client.post(self.rpc_url, headers=headers, json=body)
+            result = response.json()
+            accounts = result["result"]["value"]
+
+            token_data = {}
+            for acc in accounts:
+                parsed = acc["account"]["data"]["parsed"]["info"]
+                mint = parsed["mint"]
+                ui_amount = parsed["tokenAmount"]["uiAmount"]
+                token_data[mint] = {"amount": ui_amount}
+
+            
+
+            return token_data
+
+    async def fetch_metadata_raw(self,mint_address: str):
+        METADATA_PROGRAM_ID = solders.pubkey.Pubkey.from_string("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s")
+        mint = solders.pubkey.Pubkey.from_string(mint_address)
+        seeds = [
+            b"metadata",
+            bytes(METADATA_PROGRAM_ID),
+            bytes(mint),
+        ]
+        pda, _ = solders.pubkey.Pubkey.find_program_address(seeds, METADATA_PROGRAM_ID)
+
+        payload = {
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "getAccountInfo",
+            "params": [
+                str(pda),
+                {"encoding": "base64"}
+            ]
+        }
+
+        async with httpx.AsyncClient() as client:
+            r = await client.post(self.rpc_url, json=payload)
+            data = r.json()
+
+        if not data["result"]["value"]:
+            return None
+
+        b64_data = data["result"]["value"]["data"][0]
+        raw_bytes = base64.b64decode(b64_data)
+
+        name = raw_bytes[1+32+32 : 1+32+32+32].decode("utf-8").rstrip("\x00")
+        name = re.sub(r'[^\x20-\x7E]', '', name)     
+        return {
+            "mint": mint_address,
+            "name": name,
+            
+
+        }
+    async def transfer_token(self, to: str, amount: float):
+       
+        if not self.TOKEN_MINT:
+            raise ValueError("not set TOKEN_MINT.")
+        if not self.KEYPAIR:
+            raise ValueError("not set KEYPAIR.")
+
+        sender_pubkey = self.get_pubkey()
+        receiver_pubkey = solders.pubkey.Pubkey.from_string(to)
+        token_pubkey = solders.pubkey.Pubkey.from_string(self.TOKEN_MINT)
+
+        token = AsyncToken(self.client, token_pubkey, TOKEN_PROGRAM_ID, self.KEYPAIR)
+        sender_ata = get_associated_token_address(sender_pubkey, token_pubkey)
+        receiver_ata = get_associated_token_address(receiver_pubkey, token_pubkey)
+
+        tx = Transaction()
+
+        res = await self.client.get_account_info(receiver_ata)
+        if res.value is None:
+            tx.add(
+                create_associated_token_account(
+                    payer=sender_pubkey,
+                    owner=receiver_pubkey,
+                    mint=token_pubkey
+                )
+            )
+
+        decimals = (await token.get_mint_info()).decimals
+        real_amount = int(amount * (10 ** decimals))
+        params = TransferParams(
+            program_id=TOKEN_PROGRAM_ID,
+            source=sender_ata,
+            dest=receiver_ata,
+            owner=sender_pubkey,
+            amount=real_amount
+        )
+
+        tx.add(transfer(params))
+
+        resp = await self.client.send_transaction(tx, self.KEYPAIR, opts=TxOpts(skip_preflight=True, preflight_commitment=Confirmed))
+        return resp.value
+
+
+    async def transfer_native(self, to:str, amount: int):
+        if not self.KEYPAIR:
+            raise ValueError("not set KEYPAIR.")
+
+        sender_pubkey = self.get_pubkey()
+        receiver_pubkey = solders.pubkey.Pubkey.from_string(to)
+        ixns = [
+            ts(tsf(
+                from_pubkey=sender_pubkey,
+                to_pubkey=receiver_pubkey,
+                lamports=int(amount * LAMPORTS_PER_SOL)
+            ))
+        ]
+        msg = Message(ixns, self.get_pubkey())
+        latest_blockhash_resp = await self.client.get_latest_blockhash()
+
+        blockhash_str = latest_blockhash_resp.value.blockhash
+        tx = Transaction([self.KEYPAIR], msg, blockhash_str)
+        resp =  await self.client.send_transaction(tx)
+        return resp.value
+
+
+