shadowPaySDK 0.2.1__py3-none-any.whl → 16.7.2025.1__py3-none-any.whl

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/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/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/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/interface/sol.py

@@ -1,17 +1,29 @@
 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
+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.constants import *
 from solana.rpc.types import TxOpts, TokenAccountOpts
 from solana.rpc.types import TxOpts
 import solders
-from solders.pubkey import Pubkey
-from solders.keypair import Keypair
-from solders.signature import Signature
+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
@@ -20,44 +32,40 @@ import httpx
 import base64
 import re
 
-class SolTokens:    
-    def __init__(self, rpc_url: str = "https://api.mainnet-beta.solana.com"):
-        self.rpc_url = rpc_url
-        self.client = AsyncClient(rpc_url)
-        self.PROGRAM_ID = TOKEN_PROGRAM_ID # Default to the SPL Token Program ID
-        self.WRAPED_SOL_ID = spl.token.constants.WRAPPED_SOL_MINT
-    def set_params(self, rpc_url: Optional[str] = None, PROGRAM_ID: Optional[str] = None):
-        if rpc_url:
-            self.rpc_url = rpc_url
-            self.client = AsyncClient(rpc_url)
+
+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, Keypair]] = None):
+    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, Keypair]):
+    def set_keypair(self, KEYPAIR: Union[str, solders.keypair.Keypair]):
         if isinstance(KEYPAIR, str):
             try:
-                self.KEYPAIR = Keypair.from_base58_string(KEYPAIR)
+                self.KEYPAIR = solders.keypair.Keypair.from_base58_string(KEYPAIR)
             except Exception as e:
                 raise ValueError(f"Invalid Keypair string: {e}")
-        elif isinstance(KEYPAIR, Keypair):
+        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, Keypair]] = None):
+    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):
 
@@ -72,7 +80,7 @@ class SOL:
         raise ValueError("Keypair not set")
 
     def gen_wallet(self):
-        return Keypair()
+        return solders.keypair.Keypair()
     async def get_balance(self):
         resp = await self.client.get_balance(self.get_pubkey())
         lamports = resp.value
@@ -107,9 +115,9 @@ class SOL:
                 ui_amount = parsed["tokenAmount"]["uiAmount"]
                 token_data[mint] = {"amount": ui_amount}
 
-            filtered = {mint: data for mint, data in token_data.items() if data["amount"] > 0.001}
+            
 
-            return filtered
+            return token_data
     async def is_connected(self):
         return await self.client.is_connected()
 
@@ -117,14 +125,14 @@ class SOL:
         await self.client.close()
     
     async def fetch_metadata_raw(self,mint_address: str):
-        METADATA_PROGRAM_ID = Pubkey.from_string("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s")
-        mint = Pubkey.from_string(mint_address)
+        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, _ = Pubkey.find_program_address(seeds, METADATA_PROGRAM_ID)
+        pda, _ = solders.pubkey.Pubkey.find_program_address(seeds, METADATA_PROGRAM_ID)
 
         payload = {
             "jsonrpc": "2.0",
@@ -137,7 +145,7 @@ class SOL:
         }
 
         async with httpx.AsyncClient() as client:
-            r = await client.post("https://api.mainnet-beta.solana.com", json=payload)
+            r = await client.post(self.rpc_url, json=payload)
             data = r.json()
 
         if not data["result"]["value"]:
@@ -151,12 +159,72 @@ class SOL:
         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
 
 
 
-if __name__ == "__main__":
-    newKeypair = Keypair()
-    print("New Keypair:", newKeypair)

shadowPaySDK/types/EVMcheque.py

@@ -7,20 +7,27 @@ import httpx
 
 
 class Cheque:
-    def __init__(self, w3:Web3,private_key:str, ABI = __SHADOWPAY_ABI__ERC20__, allowed_chains = __ALLOW_CHAINS__):
+    def __init__(self, w3:Optional[Web3] = None,private_key:Optional[str] = None, ABI = __SHADOWPAY_ABI__ERC20__, allowed_chains = __ALLOW_CHAINS__, retunrn_build_tx:bool = False,address:Optional[str] = None):
         self.w3 = w3
-        print(f"chain id: {self.w3.eth.chain_id}")
-        print(f"allowed chains", allowed_chains)
+
         self.amount = None
         self.token = None
         self.private_key = private_key
         self.ABI = ABI
-
+        self.address = address
+        self.return_build_tx = retunrn_build_tx
         self.allowed_chains = allowed_chains
-        if self.__allow__():
-            print(f"Allowed chains: {self.allowed_chains}")
+        if self.w3 != None:
+            self.__allow__()
+    
+    def get_id(self, tx):
+        if isinstance(tx, str):
+            try:
+                tx = self.w3.eth.wait_for_transaction_receipt(tx)
+            except Exception as e:
+                print(f"Failed to get transaction receipt: {str(e)}")
+                return False
 
-    def __get__id(self, tx):
         try:
             logs = self.contract.events.ChequeCreated().process_receipt(tx)
             cheque_id = logs[0]["args"]["id"]
@@ -40,17 +47,15 @@ class Cheque:
     def get_contract_for_chain(self,chain_id: str):
         c = None
         for chain in __SHADOWPAY_CONTRACT_ADDRESS__ERC20__  :
-            print(f"Checking chain {chain} against {self.w3.eth.chain_id}")
             if str(chain) == str(chain_id):
                 c = __SHADOWPAY_CONTRACT_ADDRESS__ERC20__[chain_id]
-            print(f"Contract address: {c}, type {type(c)} ")
             contract_address = Web3.to_checksum_address(c)
             contract = self.w3.eth.contract(address=contract_address, abi=__SHADOWPAY_ABI__ERC20__)
             self.contract = contract
             return contract
         raise ValueError(f"Chain {chain_id} is not supported. Supported chains are: {list(__SHADOWPAY_CONTRACT_ADDRESS__ERC20__.keys())}")    
         
-    def set_parameters(self,chain_id: Optional[str] = None, w3:Optional[Web3] = None, amount:Optional[int]  = None, private_key:Optional[str] = None, token:Optional[str] = None):
+    def set_parameters(self,chain_id: Optional[str] = None, w3:Optional[Web3] = None, amount:Optional[int]  = None, private_key:Optional[str] = None, token:Optional[str] = None,address:Optional[str] = None):
         if  w3:
             self.w3 = w3
             self.get_contract_for_chain(chain_id=chain_id or self.w3.eth.chain_id)
@@ -60,38 +65,63 @@ class Cheque:
             self.private_key = private_key
         if token:
             self.token = token
+        if address:
+            self.address = address
+
     def __convert__(self):
         return self.w3.to_wei(self.amount, 'ether')
 
     async def InitCheque(self, amount,  receiver:list, private_key:Optional[str] = None):
         if  not isinstance(receiver,list):
             raise ValueError("Receiver must be a list of addresses, [""0x1234...5678", "0x2345...6789""]")
+
+        key = private_key or self.private_key
+
+        if key:
+            address = Web3.to_checksum_address(self.w3.eth.account.from_key(key).address)
+            print("InitCheque", amount, receiver, key)
         
+        elif self.address:
+            address = Web3.to_checksum_address(self.address)
+        else:
+            raise ValueError("No private key or address provided")
+
+
+
+
+
         receiver = [Web3.to_checksum_address(addr) for addr in receiver]
         estimated_gas = self.contract.functions.InitCheque(receiver).estimate_gas({
-            'from': self.w3.eth.account.from_key(private_key or self.private_key).address,
+            'from': address,
             'value': self.w3.to_wei(amount, 'ether'),
             'gasPrice': self.w3.eth.gas_price
         })
         txn = self.contract.functions.InitCheque(receiver).build_transaction({
-            'from': self.w3.eth.account.from_key(private_key or self.private_key).address,
+            'from': address,
             'value': self.w3.to_wei(amount, 'ether'),
             'nonce': self.w3.eth.get_transaction_count(
-                self.w3.eth.account.from_key(private_key or self.private_key).address
+                address
             ),
             'gas': estimated_gas,
             'gasPrice': self.w3.eth.gas_price,
             'chainId': self.w3.eth.chain_id
         })
-        signed_txn = self.w3.eth.account.sign_transaction(txn, private_key or self.private_key)
+        if self.return_build_tx:
+            return {
+                "build_tx": txn
+            }
+        
+        signed_txn = self.w3.eth.account.sign_transaction(txn, key)
         txn_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
         txn_receipt = self.w3.eth.wait_for_transaction_receipt(txn_hash)
         insert_to_dn = None
-        logs = self.__get__id(txn_receipt)
+        logs = self.get_id(txn_receipt)
         if logs:
             cheque_id = logs
         else:
             cheque_id = None
+        if txn_receipt.status != 1:
+            return False
         return {
             "hash": txn_hash.hex(),
             "chequeId": cheque_id,
@@ -110,49 +140,63 @@ class Cheque:
 
             
         account = self.w3.eth.account.from_key(private_key)
-        sender_address = account.address
+        sender_address = account.address or self.address
 
 
-        # подготовка транзакции
-        nonce = self.eth.get_transaction_count(sender_address)
+        nonce = self.w3.eth.get_transaction_count(sender_address)
 
         txn = self.contract.functions.CashOutCheque(
             Web3.to_bytes(hexstr=cheque_id)).build_transaction({
             'from': sender_address,
             'nonce': nonce,
-            'gas': 300_000,  # пример
+            'gas': 300_000,
             'gasPrice': self.w3.to_wei('5', 'gwei'),
         })
+        if self.return_build_tx:
+            return {
+                "build_tx": txn
+            }
 
-        # подписываем
         signed_txn = self.w3.eth.account.sign_transaction(txn, private_key=private_key)
 
-        # отправляем
+
         tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
 
-        print(f"⏳ Transaction sent: {tx_hash.hex()}")
         receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
-        print(f"✅ Transaction confirmed in block {receipt.blockNumber}")
-        return receipt    
+        if receipt.status != 1:
+            return False
+        return {
+            "hash": tx_hash.hex()
+        }    
 
     async def InitTokenCheque(self, token_address:str, amount, reciver:str, private_key:Optional[str] = None):
-        # collectedFes
+        key = private_key or self.private_key
+
+        if key:
+            address = Web3.to_checksum_address(self.w3.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")
+
+
+
+
         
         erc20 = shadowPaySDK.ERC20Token(w3=self.w3)
         erc20.set_params(token_address=token_address)
-        ensure_allowance = erc20.ensure_allowance(
-            private_key=self.private_key, 
+        decimals = erc20.get_decimals()
+        erc20.allowance( 
             spender=self.contract.address, 
-            amount=amount
+            owner=address,
         )
-        print(f"Ensure allowance: {ensure_allowance}")
-        decimals = erc20.get_decimals()
         estimated_gas = self.contract.functions.InitTokenCheque(
             Web3.to_checksum_address(token_address),
             int(amount * (10 ** decimals)),
             Web3.to_checksum_address(reciver)
         ).estimate_gas({
-            'from': self.w3.eth.account.from_key(self.private_key).address,
+            'from': address,
             'gasPrice': self.w3.eth.gas_price
         })
         txn = self.contract.functions.InitTokenCheque(
@@ -160,21 +204,26 @@ class Cheque:
             int(amount * (10 ** decimals)),
             Web3.to_checksum_address(reciver)
         ).build_transaction({
-            'from': self.w3.eth.account.from_key(self.private_key).address,
-            'nonce': self.w3.eth.get_transaction_count(self.w3.eth.account.from_key(self.private_key).address),
+            'from': address,
+            'nonce': self.w3.eth.get_transaction_count(address),
             'gas': estimated_gas,
             'gasPrice': self.w3.eth.gas_price
         })
-        signed_txn = self.w3.eth.account.sign_transaction(txn, self.private_key)
+        if self.return_build_tx:
+            return {
+                "build_tx": txn
+            }
+        signed_txn = self.w3.eth.account.sign_transaction(txn, key)
         txn_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
         txn_receipt = self.w3.eth.wait_for_transaction_receipt(txn_hash)
         
-        logs = self.__get__id(txn_receipt)
+        logs = self.get_id(txn_receipt)
         if logs:
             cheque_id = logs
         else:
             cheque_id = None
-
+        if txn_receipt.status != 1:
+            return False
         return {
             "hash": txn_hash.hex(),
             "chequeId": cheque_id,
@@ -188,46 +237,51 @@ class Cheque:
         
 
         
-        # Строим транзакцию
         estimated_gas = self.contract.functions.CashOutTokenCheque(
-            Web3.to_bytes(hexstr=cheque_id)  # Преобразуем строку в bytes32
+            Web3.to_bytes(hexstr=cheque_id)  
         ).estimate_gas({
-            'from': account.address,
+            'from': account.address or self.address,
             'gasPrice': self.w3.eth.gas_price
         })
         txn = self.contract.functions.CashOutTokenCheque(
             Web3.to_bytes(hexstr=cheque_id)  
         ).build_transaction({
-            'from': account.address,
-            'nonce': self.w3.eth.get_transaction_count(account.address),
+            'from': account.address or self.address,
+            'nonce': self.w3.eth.get_transaction_count(account.address or self.address),
             'gas': estimated_gas,
             'gasPrice': self.w3.eth.gas_price,
         })
+        if self.return_build_tx:
+            return {
+                "build_tx": txn
+            }
 
-        # Подписываем и отправляем транзакцию
         signed_txn = self.w3.eth.account.sign_transaction(txn, private_key=private_key)
         tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
 
-        # Получаем подтверждение
         receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
 
+        if receipt.status != 1:
+            return False
         return {
             "hash": tx_hash.hex(),
             "status": receipt.status  # 1 = success, 0 = fail
         }
     async def InitTokenChequeSwap(self, token_in:str, amount_in,token_out:str, amount_out, reciver:str, private_key:Optional[str] = None):
-        
+        key = private_key or self.private_key
+        if key:
+            address = Web3.to_checksum_address(self.w3.eth.account.from_key(key).address)
+        elif self.address:
+            address = Web3.to_checksum_address(self.address)
         erc20 = shadowPaySDK.ERC20Token(w3=self.w3)
         erc20.set_params(token_address=token_in)
-        ensure_allowance = erc20.approve(
-            private_key=self.private_key, 
+        approve = erc20.allowance(
             spender=self.contract.address, 
-            amount=amount_in,
-            token=token_in
+            owner=address,
         )
-        print(f"Ensure allowance: {ensure_allowance}")
-        decimals = erc20.get_decimals(token_in)
-        token_out_decinals = erc20.get_decimals(token_out)
+        decimals = erc20.get_decimals()
+        erc20.set_params(token_address=token_out)
+        token_out_decinals = erc20.get_decimals()
         estimated_gas = self.contract.functions.InitSwapCheque(
             Web3.to_checksum_address(reciver),
             Web3.to_checksum_address(token_in),
@@ -235,7 +289,7 @@ class Cheque:
             Web3.to_checksum_address(token_out),
             int(amount_out * (10 ** token_out_decinals)),
         ).estimate_gas({
-            'from': self.w3.eth.account.from_key(self.private_key).address,
+            'from': address,
             'gasPrice': self.w3.eth.gas_price
         })
         txn = self.contract.functions.InitSwapCheque(
@@ -245,24 +299,75 @@ class Cheque:
             Web3.to_checksum_address(token_out),
             int(amount_out * (10 ** token_out_decinals))
         ).build_transaction({
-            'from': self.w3.eth.account.from_key(self.private_key).address,
-            'nonce': self.w3.eth.get_transaction_count(self.w3.eth.account.from_key(self.private_key).address),
+            'from': address,
+            'nonce': self.w3.eth.get_transaction_count(address),
             'gas': estimated_gas,
             'gasPrice': self.w3.eth.gas_price
         })
-        signed_txn = self.w3.eth.account.sign_transaction(txn, self.private_key)
+        if self.return_build_tx:
+            return {
+                "build_tx": txn
+            }
+        signed_txn = self.w3.eth.account.sign_transaction(txn, key)
         txn_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
         txn_receipt = self.w3.eth.wait_for_transaction_receipt(txn_hash)
         
-        logs = self.__get__id(txn_receipt)
+        logs = self.get_id(txn_receipt)
         if logs:
             cheque_id = logs
         else:
             cheque_id = None
+        if txn_receipt.status != 1:
+            return False
         return {
             "hash": txn_hash.hex(),
             "chequeId": cheque_id
         }
+    
+    async def CashOutSwapCheque(self, cheque_id: str, private_key: Optional[str] = None):
+        swapDetail = await self.getSwaoDetail(cheque_id)
+        print(swapDetail)
+        if private_key is None:
+            private_key = self.private_key
+        token_out = swapDetail["tokenOut"]
+        amount_out = swapDetail["amountOut"]
+        erc20 = shadowPaySDK.ERC20Token(w3=self.w3)
+        erc20.set_params(token_address=token_out)
+        encure_allowance = erc20.ensure_allowance(
+            private_key=private_key, 
+            spender=self.contract.address, 
+            amount=amount_out,
+        )
+        estimated_gas = self.contract.functions.CashOutSwapCheque(
+            Web3.to_bytes(hexstr=cheque_id)  
+        ).estimate_gas({
+            'from': self.w3.eth.account.from_key(private_key).address,
+            'gasPrice': self.w3.eth.gas_price
+        })
+        swa = self.contract.functions.CashOutSwapCheque(
+            Web3.to_bytes(hexstr=cheque_id)  
+        ).build_transaction({
+            'from': self.w3.eth.account.from_key(private_key).address,
+            'nonce': self.w3.eth.get_transaction_count(self.w3.eth.account.from_key(private_key).address),
+            'gas': 300_000,
+            'gasPrice': self.w3.eth.gas_price
+        })
+        if self.return_build_tx:
+            return {
+                "build_tx": swa
+            }
+        signed_txn = self.w3.eth.account.sign_transaction(swa, private_key=private_key)
+        tx_hash = self.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash)
+        if receipt.status != 1:
+            return False
+        return {
+            "hash": tx_hash.hex(),
+        }
+    
+    
+    
+    
     async def getComunityPool(self):
         # fee = self.contract.functions.getCollectedFee().call()
         fee = 50000000000000
@@ -274,7 +379,11 @@ class Cheque:
         return self.contract.functions.getTreasery().call()
     async def getSwaoDetail(self, cheque_id: str):
         cheque_id_bytes = Web3.to_bytes(hexstr=cheque_id)
-        return self.contract.functions.getSwapDetail(cheque_id_bytes).call()
+        s =  self.contract.functions.getSwapDetail(cheque_id_bytes).call()
+        return{
+            "tokenOut": s[0],
+            "amountOut": s[1],
+        }
 class NFTcheque:
     def __init__(self, w3:Web3, token:str, amount:int, spender:str):
         self.w3 = w3
@@ -306,20 +415,3 @@ class NFTcheque:
 
 
 
-async def create_cheque(id, type, chain_id, receiver, sender):
-    async with httpx.AsyncClient() as client:
-        response = await client.post(
-            __CREATE__CHEQUE__,
-            json={
-                "cheque_id": id,
-                "chain_id":chain_id, 
-                "receiver": receiver,
-                "type": type,
-                "sender":sender
-            }
-        )
-        if response.status_code == 200:
-            return response.json()
-        else:
-            print(f"Failed to create cheque: {response.text}")
-            return False

shadowPaySDK/types/SOLcheque.py

@@ -1,27 +1,284 @@
 
 import anchorpy
 from anchorpy import Idl, Provider, Wallet
+import solders
 from shadowPaySDK.interface.sol import SOL
-from solders.keypair import Keypair
-import solana.constants as constants
-import solana.constants as sol_constants
+import solders  
 import spl.token.constants as spl_constants
+from solana.rpc.api import Client
+
+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
+from solders.instruction import Instruction, AccountMeta
+from solders.rpc.config import RpcSendTransactionConfig
+from solders.message import Message
+import spl
+import spl.token
+import spl.token.constants
+from spl.token.instructions import get_associated_token_address, create_associated_token_account,TransferCheckedParams, transfer_checked, transfer, close_account, TransferParams
+from solders.system_program import transfer as ts
+from solders.system_program import TransferParams as tsf
+from solders.pubkey import Pubkey
+import os
+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.system_program import create_account,CreateAccountParams
+
+# 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
+import pprint
+import httpx
+import base64
+import re
+import struct
+from shadowPaySDK.const import LAMPORTS_PER_SOL, PROGRAM_ID, CONFIG_PDA
 
 
 
 class SOLCheque:
-        def __init__(self, rpc_url: str = "https://api.mainnet-beta.solana.com", keystore: Wallet = None):
+        def __init__(self, rpc_url: str = "https://api.mainnet-beta.solana.com", key: Wallet = None):
             self.rpc_url = rpc_url
-            self.keystore = keystore
-            self.provider = Provider(self.rpc_url, self.keystore)
+            if key:
+                self.key = solders.keypair.Keypair.from_base58_string(key)
+            self.provider = Client(rpc_url)
             self.WRAPED_SOL = spl_constants.WRAPPED_SOL_MINT    # wrapped SOL token mint address
             # self.idl = Idl.from_json(sol_interface.Idl)  # Load the IDL for the program
         def get(self, keypair = None):
-              pubkey = SOL.get_pubkey(KEYPAIR=Keypair.from_base58_string(self.keystore))
+              pubkey = SOL.get_pubkey(KEYPAIR=solders.keypair.Keypair.from_base58_string(self.keystore))
 
               return pubkey
-        
+        def get_config(self):
+            program_id = PROGRAM_ID
+            config_pda, _ = Pubkey.find_program_address([b"config"], program_id)
+
+            response = self.provider.get_account_info(config_pda)
+            if response.value is None:
+                print("❌ Config PDA not found.")
+                return None
+
+            # 🧠 У тебя data — это list[int], его нужно превратить в bytes
+            raw = bytes(response.value.data)
+
+            if len(raw) < 89:
+                print("❌ Invalid config data length.")
+                return None
+
+            admin = Pubkey.from_bytes(raw[0:32])
+            treasury = Pubkey.from_bytes(raw[32:64])
+            fee_bps = struct.unpack("<Q", raw[64:72])[0]
+            token_in_bps = struct.unpack("<Q", raw[72:80])[0]
+            token_out_bps = struct.unpack("<Q", raw[80:88])[0]
+            initialized = bool(raw[88])
+
+            
+            return {
+                "pda": str(config_pda),
+                "admin": str(admin),
+                "treasury": str(treasury),
+                "fee_bps": fee_bps,
+                "token_in_bps": token_in_bps,
+                "token_out_bps": token_out_bps,
+                "initialized": initialized,
+            }
+        def set_params(self, rpc_url = None, key = None):
+            if rpc_url:
+                self.rpc_url = rpc_url
+                self.provider = Client(rpc_url)
+            if key:
+                self.key = solders.keypair.Keypair.from_base58_string(key)
+        # init_cheque & claim_cheque status on 15.07.2025 work
+
+        def init_cheque(self, cheque_amount, recipient: str, SPACE: int = 100, build_tx: bool = False):
+            """
+            Initialize a cheque withc the specified amount and recipient.
+            """
+            # if not self.key:
+            #     raise ValueError("Keypair is not set. Please set the keypair before initializing a cheque.")
+            CHEQUE_PDA_SIGNATURE = None
+            CHEQUE_SPACE = SPACE  
+            CHEQUE_RENT = self.provider.get_minimum_balance_for_rent_exemption(CHEQUE_SPACE)
+            sol = SOL(
+                KEYPAIR=self.key  
+            )
+            payer = self.key
+            pubkey = self.key.pubkey()
+            newAcc = solders.keypair.Keypair()
+            newAccPubkey = newAcc.pubkey()
+            ix_create = create_account(
+                params=CreateAccountParams(
+                from_pubkey=pubkey,
+                to_pubkey=newAccPubkey,
+                lamports=CHEQUE_RENT.value,
+                space=CHEQUE_SPACE,
+                owner=PROGRAM_ID
+                )
+            )
+            recent_blockhash = self.provider.get_latest_blockhash().value.blockhash
+            message = Message(instructions=[ix_create], payer=pubkey)
+
+            t = Transaction(message=message, from_keypairs=[payer, newAcc], recent_blockhash=recent_blockhash)
+            
+            r = self.provider.send_transaction(t,opts=TxOpts())
+            CHEQUE_PDA_SIGNATURE = r.value
+            CHEQUE_PDA = newAccPubkey  
+
+
+
+            total_lamports = int(cheque_amount * LAMPORTS_PER_SOL)
+
+
+            r = Pubkey.from_string(recipient)  
+
+            data = bytes([0]) + bytes(r) + struct.pack("<Q", total_lamports)
+
+            cfg = self.get_config()
+            tresury = cfg["treasury"]
+            instruction = Instruction(
+                program_id=PROGRAM_ID,
+                data=data,  
+                accounts=[
+                    AccountMeta(pubkey=pubkey, is_signer=True, is_writable=True),     # payer
+                    AccountMeta(pubkey=CHEQUE_PDA, is_signer=False, is_writable=True), # cheque PDA
+                    AccountMeta(pubkey=Pubkey.from_string("11111111111111111111111111111111"), is_signer=False, is_writable=False),
+                    AccountMeta(pubkey=Pubkey.from_string(tresury), is_signer=False, is_writable=True),  # treasury
+
+                ]
+            )
+
+            recent_blockhash = self.provider.get_latest_blockhash().value.blockhash
+            message = Message(instructions=[instruction], payer=pubkey)
+            tx = Transaction(message=message, from_keypairs=[payer], recent_blockhash=recent_blockhash)
+            response = self.provider.send_transaction(tx,opts=TxOpts(skip_preflight=True))
+            confirm = self.provider.confirm_transaction(response.value)
+            
+            data = {
+                "cheque_pda": str(CHEQUE_PDA),
+                "signature": str(response.value),
+                "create_signature": str(CHEQUE_PDA_SIGNATURE),
+                "cheque_amount": cheque_amount,
+                "pda_rent_sol": CHEQUE_RENT.value / LAMPORTS_PER_SOL,
+            }
+            return data
+
+        def claim_cheque(self, pda_acc: str ):
+            instruction_data = bytes([1])
+            payer = self.key
+            payer_pubkey = payer.pubkey()
+            cfg = self.get_config()   
+            tressary = cfg["treasury"]
+
+
+            ix = Instruction(
+                program_id=PROGRAM_ID,
+                data=instruction_data,
+                accounts = [
+                    AccountMeta(pubkey=payer_pubkey, is_signer=True, is_writable=True),
+                    AccountMeta(pubkey=Pubkey.from_string(pda_acc), is_signer=False, is_writable=True),
+                    AccountMeta(pubkey=CONFIG_PDA[0], is_signer=False, is_writable=True),  # rent receiver
+                    AccountMeta(pubkey=Pubkey.from_string(tressary), is_signer=False, is_writable=True)  # treasury
+                ]
+            )
+
+            recent_blockhash = self.provider.get_latest_blockhash().value.blockhash
+            message = Message(instructions=[ix], payer=payer_pubkey)
+            tx = Transaction(message=message, from_keypairs=[payer], recent_blockhash=recent_blockhash)
+            response = self.provider.send_transaction(tx,opts=TxOpts(skip_preflight=True))
+            return {
+                "signature": str(response.value),
+                "pda_account": pda_acc,
+            }
+
+        # init_token_cheque need fix...
+
+        def init_token_cheque(self, token_mint: str, token_amount,token_decimals, recipient: str, treasury: str, CHEQUE_SPACE: int = 105):
+            if not self.key:
+                raise ValueError("Keypair not set")
+
+            payer = self.key
+            payer_pubkey = payer.pubkey()
+            token_mint_pubkey = Pubkey.from_string(token_mint)
+            recipient_pubkey = Pubkey.from_string(recipient)
+            treasury_pubkey = Pubkey.from_string(treasury)
+
+            cheque_acc = solders.keypair.Keypair()
+            cheque_pda = cheque_acc.pubkey()
+
+            rent = self.provider.get_minimum_balance_for_rent_exemption(CHEQUE_SPACE).value
+
+            create_cheque_acc = create_account(
+                CreateAccountParams(
+                    from_pubkey=payer_pubkey,
+                    to_pubkey=cheque_pda,
+                    lamports=rent,
+                    space=CHEQUE_SPACE,
+                    owner=PROGRAM_ID
+                )
+            )
+
+            tx1 = Transaction(
+                message=Message(instructions=[create_cheque_acc], payer=payer_pubkey),
+                recent_blockhash=self.provider.get_latest_blockhash().value.blockhash,
+                from_keypairs=[payer, cheque_acc]
+            )
+            self.provider.send_transaction(tx1, opts=TxOpts(skip_preflight=True))
+
+            sender_ata = get_associated_token_address(payer_pubkey, token_mint_pubkey)
+            cheque_ata = get_associated_token_address(cheque_pda, token_mint_pubkey)
+            treasury_ata = get_associated_token_address(treasury_pubkey, token_mint_pubkey)
+
+            ix_create_ata = create_associated_token_account(payer_pubkey, cheque_pda, token_mint_pubkey)
+
+            amount = int(token_amount * (10 ** token_decimals))
+            
+
+
+            data = bytes([2]) + struct.pack("<Q", amount)
+
+            ix_program = Instruction(
+                program_id=PROGRAM_ID,
+                data=data,
+                accounts=[
+                    AccountMeta(payer_pubkey, is_signer=True, is_writable=True),
+                    AccountMeta(cheque_pda, is_signer=True, is_writable=True),
+                    AccountMeta(token_mint_pubkey, is_signer=False, is_writable=True),
+                    AccountMeta(sender_ata, is_signer=False, is_writable=True),
+                    AccountMeta(cheque_ata, is_signer=False, is_writable=True),
+                    AccountMeta(treasury_ata, is_signer=False, is_writable=True),
+                    AccountMeta(Pubkey.from_string("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"), is_signer=False, is_writable=False),
+                ]
+            )
 
+            # === 6. Собираем и отправляем всё в одном tx ===
+            print("Accounts (ix_program):")
+            for i, acc in enumerate(ix_program.accounts):
+                print(f"[{i}] {acc.pubkey} | signer={acc.is_signer} | writable={acc.is_writable}")
 
+            tx2 = Transaction(
+                message=Message(instructions=[ix_create_ata,  ix_program], payer=payer_pubkey),
+                recent_blockhash=self.provider.get_latest_blockhash().value.blockhash,
+                from_keypairs=[payer, cheque_acc]
+            )
 
-  
+            sig = self.provider.send_transaction(tx2, opts=TxOpts(skip_preflight=True)).value
+            return {
+                "cheque_pda": str(cheque_pda),
+                "signature": str(sig),
+                "amount": token_amount
+            }
+        def claim_token_cheque(self, pda_acc: str):
+            pass

{shadowpaysdk-0.2.1.dist-info → shadowpaysdk-16.7.2025.1.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: shadowPaySDK
-Version: 0.2.1
+Version: 16.7.2025.1
 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.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+shadowPaySDK/__init__.py,sha256=CMwAuP_6hJN-WueU-XlTNta9Oyd28sFo8OojdgD_pxA,681
+shadowPaySDK/api.py,sha256=cv5Z171cOh-Idi-lMA4AORzeGDPPrk8BCQ9e5V9MAaM,1461
+shadowPaySDK/const.py,sha256=dIifSDi2SEW7W3e-Z1nG3TwpAqPNnXvnFipGP0cgPwE,10318
+shadowPaySDK/interface/__init__.py,sha256=ggSZCV22udnzXm_Wv_3x6VN3hNIAEiwgwHZc2Jwc688,146
+shadowPaySDK/interface/erc20.py,sha256=7p8eU5LzhI2MsH80PZhq6IRhbfMGlNYucGl3OtyS9SI,4669
+shadowPaySDK/interface/erc721.py,sha256=4AlWfDjrvl85wFocnN93j-oM54kTsLLwv9SdtcLj4eM,3094
+shadowPaySDK/interface/sol.py,sha256=TDp62OtQkR8Wy9I4UBVmL_K_FQeMVS--Lojgbvq5T2E,8146
+shadowPaySDK/types/EVMcheque.py,sha256=8M1EzpZGqf4uidrd9yDKiR7BvIl85p93A_9AMZtshSs,14570
+shadowPaySDK/types/SOLcheque.py,sha256=h1u-VaIhdb5hFWScdePCQDeDhIyyFhKgtZWmZ8vckh4,11991
+shadowPaySDK/types/__init__.py,sha256=sG6pNZfKGvENXqsnv6MrQtKrJ898fAXkMvAZY1k1-Qg,97
+shadowPaySDK/utils/__init__.py,sha256=aja3iYO4rT-ptMM-pzw0GRFTziBdXdcEi-4kE84zH64,61
+shadowPaySDK/utils/utils.py,sha256=g4bGvLDdjhNGsAj1eaZnNWFNaiN-cVhhM-5PrnG5aIQ,720
+shadowpaysdk-16.7.2025.1.dist-info/licenses/LICENSE,sha256=EG13vNmyBfkG3oKj40oOYfUGLKko8OouU6PfO6MlAk4,1066
+shadowpaysdk-16.7.2025.1.dist-info/METADATA,sha256=Df0LLF--lTt4X9nDkbor0opwMawm-9LeaFSZOrqZnWE,1046
+shadowpaysdk-16.7.2025.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+shadowpaysdk-16.7.2025.1.dist-info/top_level.txt,sha256=RSJc73GEf31NMdZp9KovEduzfhm10eQ2t5GTZ44aN1U,13
+shadowpaysdk-16.7.2025.1.dist-info/RECORD,,

shadowpaysdk-0.2.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-shadowPaySDK/__init__.py,sha256=f3O3u7UX-WTEuy1DPS6vQ8w672nzR1ZbVMu8hciqxM8,821
-shadowPaySDK/api.py,sha256=cv5Z171cOh-Idi-lMA4AORzeGDPPrk8BCQ9e5V9MAaM,1461
-shadowPaySDK/const.py,sha256=WC560zlT9MlG9QKlJb8Ww6ITfL4xR6vRH4kcGzVHFRI,9893
-shadowPaySDK/interface/__init__.py,sha256=QceU3dWteSgwvMnR3JDVdmS8OgdRPjvl9JzRs7IsA74,152
-shadowPaySDK/interface/erc20.py,sha256=rsdfjIrPNxC_xHbUT9FQbNhURdIqZHcylxTbskPHu1k,4453
-shadowPaySDK/interface/erc721.py,sha256=4AlWfDjrvl85wFocnN93j-oM54kTsLLwv9SdtcLj4eM,3094
-shadowPaySDK/interface/sol.py,sha256=xgJZsg4xE-_dRctGUW_mHuGj_o_0OlKNp4Gr7IXvTEc,5586
-shadowPaySDK/types/EVMcheque.py,sha256=lmPvHlt-ERkaYx2DTYwGmbF_TI1B_ZTT3G_FIQPBm_o,12466
-shadowPaySDK/types/SOLcheque.py,sha256=gmivsCK4hm_6pzQ9whPGuQ_f7qfcUfiJfQgb5ZsJYDo,884
-shadowPaySDK/types/__init__.py,sha256=sG6pNZfKGvENXqsnv6MrQtKrJ898fAXkMvAZY1k1-Qg,97
-shadowPaySDK/utils/__init__.py,sha256=aja3iYO4rT-ptMM-pzw0GRFTziBdXdcEi-4kE84zH64,61
-shadowPaySDK/utils/utils.py,sha256=g4bGvLDdjhNGsAj1eaZnNWFNaiN-cVhhM-5PrnG5aIQ,720
-shadowpaysdk-0.2.1.dist-info/licenses/LICENSE,sha256=EG13vNmyBfkG3oKj40oOYfUGLKko8OouU6PfO6MlAk4,1066
-shadowpaysdk-0.2.1.dist-info/METADATA,sha256=oVHKTeuCSJ64v1EKXBhslX7U97X2VP68Cdgpn9LWwCw,868
-shadowpaysdk-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-shadowpaysdk-0.2.1.dist-info/top_level.txt,sha256=RSJc73GEf31NMdZp9KovEduzfhm10eQ2t5GTZ44aN1U,13
-shadowpaysdk-0.2.1.dist-info/RECORD,,