shadowPaySDK 0.2.1__tar.gz → 16.7.2025__tar.gz

{shadowpaysdk-0.2.1 → shadowpaysdk-16.7.2025}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: shadowPaySDK
-Version: 0.2.1
+Version: 16.7.2025
 Summary: ShadowPay SDK for ERC20/ERC721 and P2P smart contract interaction
-Author: dazarius_
+Author: dazay(aka dazarius_)
 Author-email: your@email.com
 License: MIT
 Classifier: Programming Language :: Python :: 3
@@ -11,10 +11,10 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: web3>=6.0.0
-Requires-Dist: requests>=2.28.0
-Requires-Dist: solana==0.36.7
-Requires-Dist: anchorpy>=0.21.0
+Requires-Dist: web3
+Requires-Dist: requests
+Requires-Dist: solana
+Requires-Dist: anchorpy
 Requires-Dist: solders
 Requires-Dist: httpx==0.28.1
 Dynamic: author
@@ -28,11 +28,24 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# shadowPayS
+# shadowPaySdk
 
 ```bash
 pip3 install shadowPaySDK
+pip3 install --break-system-packages git+https://github.com/dazarius/SDK.git
 ```
+```example to use cheque
+
+
+
+
+
+import shadowPaySDK
+
+
+EVMcheque = shadowPaySDK.Cheque(
+    retunrn_build_tx=True
+)
 
 
 

shadowpaysdk-16.7.2025/README.md

@@ -0,0 +1,21 @@
+# shadowPaySdk
+
+```bash
+pip3 install shadowPaySDK
+pip3 install --break-system-packages git+https://github.com/dazarius/SDK.git
+```
+```example to use cheque
+
+
+
+
+
+import shadowPaySDK
+
+
+EVMcheque = shadowPaySDK.Cheque(
+    retunrn_build_tx=True
+)
+
+
+

{shadowpaysdk-0.2.1 → shadowpaysdk-16.7.2025}/setup.py

@@ -2,11 +2,11 @@ from setuptools import setup, find_packages
 
 setup(
     name='shadowPaySDK',
-    version='0.2.1',
+    version='16.07.2025',
     description='ShadowPay SDK for ERC20/ERC721 and P2P smart contract interaction',
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',
-    author='dazarius_',
+    author='dazay(aka dazarius_)',
     author_email='your@email.com',
     license='MIT',
     packages=find_packages(),
@@ -16,10 +16,10 @@ setup(
         'Operating System :: OS Independent',
     ],
     install_requires=[
-        'web3>=6.0.0',
-        'requests>=2.28.0',
-        'solana==0.36.7',
-        'anchorpy>=0.21.0',
+        'web3',
+        'requests',
+        'solana',
+        'anchorpy',
         
         'solders',
         'httpx==0.28.1'                 

{shadowpaysdk-0.2.1 → shadowpaysdk-16.7.2025}/shadowPaySDK/__init__.py

@@ -1,12 +1,10 @@
 import json
 from shadowPaySDK.interface.erc20 import ERC20Token
 from shadowPaySDK.interface.erc721 import ERC721Token
-from shadowPaySDK.interface.sol import SolTokens
-from shadowPaySDK.interface.sol import SOL    
+from shadowPaySDK.interface.sol import SOL as sol
 from shadowPaySDK.types.EVMcheque import Cheque
 from shadowPaySDK.types.SOLcheque import SOLCheque
 from shadowPaySDK.const import __ERC20_ABI__, __SHADOWPAY_ABI__ERC20__,__ALLOW_CHAINS__, __SHADOWPAY_CONTRACT_ADDRESS__ERC20__
-from shadowPaySDK.api import __MAIN__URL__, __CREATE__CHEQUE__, get_my_cheques, create_cheque
 
 
 # from shadowPaySDK.utils import parse_tx as PARSE_TX           

{shadowpaysdk-0.2.1 → shadowpaysdk-16.7.2025}/shadowPaySDK/const.py

@@ -1,5 +1,5 @@
 import json
-
+from solders.pubkey import Pubkey
 __ALLOW_CHAINS__ = [
     56,  # BSC Mainnet
     97,  # BSC Testnet
@@ -11,6 +11,9 @@ __ALLOW_CHAINS__ = [
     0xa 
 ]
 
+
+
+
 __VERSION__ = "0.1.2"
 
 
@@ -27,7 +30,7 @@ __ERC20_ABI__ = json.loads("""[
 ]""")
 
 __SHADOWPAY_CONTRACT_ADDRESS__ERC20__ = {
-    97: "0x17a82E53a3b3f2acA7ceae8CA6B6b3B8F14e4441"
+    97: "0x5487C0DdCbD5465F26B446c6CAB88D8d6F7DF23b"
   }
 
 __SHADOWPAY_ABI__ERC20__= json.loads("""[
@@ -543,4 +546,13 @@ __SHADOWPAY_ABI__ERC20__= json.loads("""[
 __SHADOWPAY_ABI__ERC721__ = json.loads("""[]""")
 __SHADOWPAY_CONTRACT_ADDRESS__ERC721__ = {
     "0x1": "0x3c5b8d6f2e"
-}
+}
+
+SOLANA_SYSTEM_PROGRAMM = "11111111111111111111111111111111"
+LAMPORTS_PER_SOL = 1_000_000_000
+WRAPED_SOL = "So11111111111111111111111111111111111111112"
+TOKEN_PROGRAM_ID = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+NATIVE_DECIMALS: int = 9
+PROGRAM_ID = Pubkey.from_string("CrfYLvU4FdVjkBno2rRi6u5U6nGCykpQnQKSBg3uVXTw")
+
+CONFIG_PDA=Pubkey.find_program_address([b"config"], PROGRAM_ID)

{shadowpaysdk-0.2.1 → shadowpaysdk-16.7.2025}/shadowPaySDK/interface/__init__.py

@@ -1,4 +1,4 @@
 from .erc20 import ERC20Token as ERC20
 from .erc721 import ERC721Token as ERC721
-from .sol import SolTokens as SPL
-__all__ = ["ERC20", "ERC721", "SPL"]
+from .sol import SOL as sol
+__all__ = ["ERC20", "ERC721", "sol"]

{shadowpaysdk-0.2.1 → shadowpaysdk-16.7.2025}/shadowPaySDK/interface/erc20.py

@@ -6,9 +6,10 @@ from shadowPaySDK.const import __ERC20_ABI__
 
 
 class ERC20Token:
-    def __init__(self,  w3:Web3, explorer: Optional[str] = None):
+    def __init__(self,  w3: Optional[Web3] = None, explorer: Optional[str] = None):
         self.web3 = w3
         self.explorer = explorer
+
         self.address = None
         self.contract = None
 
@@ -21,7 +22,7 @@ class ERC20Token:
 
     def _ensure_contract(self):
         if not self.contract:
-            raise ValueError("Token address is not set. Use set_token(token_address) first.")
+            raise ValueError("Token address is not set. Use set_params first.")
 
     def _format_tx(self, tx_hash: str) -> str:
         if self.explorer:
@@ -30,10 +31,9 @@ class ERC20Token:
     def gen_wallet(self) -> str:
         account = self.web3.eth.account.create()
         return account
-    def get_decimals(self, token) -> int:
+    def get_decimals(self) -> int:
         self._ensure_contract()
-        if token:
-            self.set_params(token_address=token)
+
         return self.contract.functions.decimals().call()
 
     def get_symbol(self) -> str:
@@ -45,21 +45,21 @@ class ERC20Token:
         raw = self.contract.functions.balanceOf(Web3.to_checksum_address(wallet_address)).call()
         return raw / (10 ** self.get_decimals())
 
-    def allowance(self, owner: str, spender: str, token) -> float:
+    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(token))
+        return raw / (10 ** self.get_decimals())
 
-    def ensure_allowance(self, private_key: str, spender: str, amount, token) -> Union[bool, str]:
+    def ensure_allowance(self, private_key: str, spender: str, amount) -> Union[bool, str]:
         self._ensure_contract()
         account = self.web3.eth.account.from_key(private_key)
-        current = self.allowance(account.address, spender, token)
+        current = self.allowance(account.address, spender)
         if current == amount:
             return True
-        return self.approve(private_key, spender, amount, token)
+        return self.approve(private_key, spender, amount)
 
     def transfer(self, private_key: str, to: str, amount: float) -> str:
         self._ensure_contract()
@@ -87,28 +87,39 @@ 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, token) -> str:
+    def approve(self,  spender: str, amount: float,address:Optional[str] = None,  private_key: Optional[str] = None, build_tx: bool = False) -> str:
+        
         self._ensure_contract()
-        account = self.web3.eth.account.from_key(private_key)
-        decimals = self.get_decimals(token=token)
+        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")
+
+        decimals = self.get_decimals()
         amount = int(amount * (10 ** decimals))
         
         txn = self.contract.functions.approve(
             Web3.to_checksum_address(spender),
             amount
         ).build_transaction({
-            'from': account.address,
-            'nonce': self.web3.eth.get_transaction_count(account.address),
+            'from': address,
+            'nonce': self.web3.eth.get_transaction_count(address),
             'gas': 60000,
             
             'gasPrice': self.web3.eth.gas_price,
         })
+        if build_tx:
+            return txn
 
-        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)
         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"approve: {self._format_tx(self.web3.to_hex(tx_hash))}"
+        return f"{self._format_tx(self.web3.to_hex(tx_hash))}"
 

shadowpaysdk-16.7.2025/shadowPaySDK/interface/sol.py

@@ -0,0 +1,230 @@
+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 is_connected(self):
+        return await self.client.is_connected()
+
+    async def close(self):
+        await self.client.close()
+    
+    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
+
+
+