shadowPaySDK 0.1.1__py3-none-any.whl → 0.2.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:Web3, 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_token(token_address) first.")
 
     def _format_tx(self, tx_hash: str) -> str:
         if self.explorer:
             return f"{self.explorer.rstrip('/')}/tx/{tx_hash}"
         return tx_hash
-
-
-
-    def get_decimals(self) -> int:
+    def gen_wallet(self) -> str:
+        account = self.web3.eth.account.create()
+        return account
+    def get_decimals(self, token) -> int:
+        self._ensure_contract()
+        if token:
+            self.set_params(token_address=token)
         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 / (10 ** self.get_decimals())
 
-    def allowance(self, owner: str, spender: str) -> float:
+    def allowance(self, owner: str, spender: str, token) -> 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 / (10 ** self.get_decimals(token))
 
-    def ensure_allowance(self, private_key: str, spender: str, amount: float) -> Union[bool, str]:
+    def ensure_allowance(self, private_key: str, spender: str, amount, token) -> 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, token)
+        if current == amount:
             return True
-        return self.approve(private_key, spender, amount)
-    
+        return self.approve(private_key, spender, amount, token)
+
     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),
+            value
+        ).estimate_gas({
+            'from': account.address,
+            'gasPrice': self.web3.to_wei('5', 'gwei'),
+        })
         txn = self.contract.functions.transfer(
             Web3.to_checksum_address(to),
             value
         ).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,28 @@ 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:
+    def approve(self, private_key: str, spender: str, amount: float, token) -> str:
+        self._ensure_contract()
         account = self.web3.eth.account.from_key(private_key)
-        decimals = self.get_decimals()
-        value = int(amount * (10 ** decimals))
-
+        decimals = self.get_decimals(token=token)
+        amount = int(amount * (10 ** decimals))
+        
         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'),
+            'gas': 60000,
+            
+            'gasPrice': self.web3.eth.gas_price,
         })
 
         signed = self.web3.eth.account.sign_transaction(txn, private_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"approve: {self._format_tx(self.web3.to_hex(tx_hash))}"
 

shadowPaySDK/interface/sol.py

@@ -0,0 +1,162 @@
+import asyncio
+from solana.rpc.async_api import AsyncClient, GetTokenAccountsByOwnerResp
+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.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
+import anchorpy
+from anchorpy import Provider, Wallet, Idl
+from typing import Optional, Union
+import pprint
+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)
+
+class SOL:
+    
+    def __init__(self, rpc_url = "https://api.mainnet-beta.solana.com", KEYPAIR: Optional[Union[str, Keypair]] = None):
+            self.rpc_url = rpc_url
+            self.client = AsyncClient(rpc_url)
+            self.KEYPAIR = None
+
+            if KEYPAIR:
+                self.set_keypair(KEYPAIR)
+
+    def set_keypair(self, KEYPAIR: Union[str, Keypair]):
+        if isinstance(KEYPAIR, str):
+            try:
+                self.KEYPAIR = Keypair.from_base58_string(KEYPAIR)
+            except Exception as e:
+                raise ValueError(f"Invalid Keypair string: {e}")
+        elif isinstance(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):
+        if rpc_url:
+            self.rpc_url = rpc_url
+            self.client = AsyncClient(rpc_url)
+        if KEYPAIR:
+            self.set_keypair(KEYPAIR)            
+
+    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 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}
+
+            filtered = {mint: data for mint, data in token_data.items() if data["amount"] > 0.001}
+
+            return filtered
+    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 = Pubkey.from_string("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s")
+        mint = Pubkey.from_string(mint_address)
+        seeds = [
+            b"metadata",
+            bytes(METADATA_PROGRAM_ID),
+            bytes(mint),
+        ]
+        pda, _ = 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("https://api.mainnet-beta.solana.com", 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,
+        }
+
+
+
+
+
+if __name__ == "__main__":
+    newKeypair = Keypair()
+    print("New Keypair:", newKeypair)

shadowPaySDK/types/EVMcheque.py

@@ -0,0 +1,325 @@
+import shadowPaySDK
+from shadowPaySDK.const import __SHADOWPAY_ABI__ERC20__, __ALLOW_CHAINS__, __SHADOWPAY_CONTRACT_ADDRESS__ERC20__
+from shadowPaySDK.api import  __CREATE__CHEQUE__
+from web3 import Web3
+from typing import Optional
+import httpx
+
+
+class Cheque:
+    def __init__(self, w3:Web3,private_key:str, ABI = __SHADOWPAY_ABI__ERC20__, allowed_chains = __ALLOW_CHAINS__):
+        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.allowed_chains = allowed_chains
+        if self.__allow__():
+            print(f"Allowed chains: {self.allowed_chains}")
+
+    def __get__id(self, tx):
+        try:
+            logs = self.contract.events.ChequeCreated().process_receipt(tx)
+            cheque_id = logs[0]["args"]["id"]
+            return cheque_id.hex()
+        except Exception as e:
+            print(f"Failed to get cheque ID from transaction receipt: {str(e)}")
+            return False
+    def __allow__(self):
+        for chain in self.allowed_chains:
+
+            if chain == self.w3.eth.chain_id:
+                self.get_contract_for_chain(chain_id=self.w3.eth.chain_id)
+
+                return True
+            
+        raise ValueError(f"Chain {str(self.w3.eth.chain_id)} is not allowed. Allowed chains are: {self.allowed_chains}")
+    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):
+        if  w3:
+            self.w3 = w3
+            self.get_contract_for_chain(chain_id=chain_id or self.w3.eth.chain_id)
+        if amount:
+            self.amount = amount
+        if private_key:
+            self.private_key = private_key
+        if token:
+            self.token = token
+    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""]")
+        
+        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,
+            '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,
+            '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
+            ),
+            '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)
+        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)
+        if logs:
+            cheque_id = logs
+        else:
+            cheque_id = None
+        return {
+            "hash": txn_hash.hex(),
+            "chequeId": cheque_id,
+        }
+
+ 
+
+
+    async def CashOutCheque(
+        self,
+        private_key: str,
+        cheque_id: str  # hex-строка типа "0xabc..."
+    ):
+        if not private_key:
+            private_key = self.private_key
+
+            
+        account = self.w3.eth.account.from_key(private_key)
+        sender_address = account.address
+
+
+        # подготовка транзакции
+        nonce = self.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,  # пример
+            'gasPrice': self.w3.to_wei('5', 'gwei'),
+        })
+
+        # подписываем
+        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    
+
+    async def InitTokenCheque(self, token_address:str, amount, reciver:str, private_key:Optional[str] = None):
+        # collectedFes
+        
+        erc20 = shadowPaySDK.ERC20Token(w3=self.w3)
+        erc20.set_params(token_address=token_address)
+        ensure_allowance = erc20.ensure_allowance(
+            private_key=self.private_key, 
+            spender=self.contract.address, 
+            amount=amount
+        )
+        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,
+            'gasPrice': self.w3.eth.gas_price
+        })
+        txn = self.contract.functions.InitTokenCheque(
+            Web3.to_checksum_address(token_address),
+            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),
+            'gas': estimated_gas,
+            'gasPrice': self.w3.eth.gas_price
+        })
+        signed_txn = self.w3.eth.account.sign_transaction(txn, self.private_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)
+        if logs:
+            cheque_id = logs
+        else:
+            cheque_id = None
+
+        return {
+            "hash": txn_hash.hex(),
+            "chequeId": cheque_id,
+        }
+
+    async def CashOutTokenCheque(self, cheque_id: str, private_key: Optional[str] = None):
+        if private_key is None:
+            private_key = self.private_key
+        
+        account = self.w3.eth.account.from_key(private_key)
+        
+
+        
+        # Строим транзакцию
+        estimated_gas = self.contract.functions.CashOutTokenCheque(
+            Web3.to_bytes(hexstr=cheque_id)  # Преобразуем строку в bytes32
+        ).estimate_gas({
+            'from': account.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),
+            'gas': estimated_gas,
+            'gasPrice': self.w3.eth.gas_price,
+        })
+
+        # Подписываем и отправляем транзакцию
+        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)
+
+        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):
+        
+        erc20 = shadowPaySDK.ERC20Token(w3=self.w3)
+        erc20.set_params(token_address=token_in)
+        ensure_allowance = erc20.approve(
+            private_key=self.private_key, 
+            spender=self.contract.address, 
+            amount=amount_in,
+            token=token_in
+        )
+        print(f"Ensure allowance: {ensure_allowance}")
+        decimals = erc20.get_decimals(token_in)
+        token_out_decinals = erc20.get_decimals(token_out)
+        estimated_gas = self.contract.functions.InitSwapCheque(
+            Web3.to_checksum_address(reciver),
+            Web3.to_checksum_address(token_in),
+            int(amount_in * (10 ** decimals)),
+            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,
+            'gasPrice': self.w3.eth.gas_price
+        })
+        txn = self.contract.functions.InitSwapCheque(
+            Web3.to_checksum_address(reciver),
+            Web3.to_checksum_address(token_in),
+            int(amount_in * (10 ** decimals)),
+            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),
+            'gas': estimated_gas,
+            'gasPrice': self.w3.eth.gas_price
+        })
+        signed_txn = self.w3.eth.account.sign_transaction(txn, self.private_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)
+        if logs:
+            cheque_id = logs
+        else:
+            cheque_id = None
+        return {
+            "hash": txn_hash.hex(),
+            "chequeId": cheque_id
+        }
+    async def getComunityPool(self):
+        # fee = self.contract.functions.getCollectedFee().call()
+        fee = 50000000000000
+        half_fee_eth = self.w3.from_wei(fee // 2, 'ether')
+        return half_fee_eth
+    async def getOwner(self):
+        return self.contract.functions.getOwner().call()
+    async def getTreasery(self):
+        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()
+class NFTcheque:
+    def __init__(self, w3:Web3, token:str, amount:int, spender:str):
+        self.w3 = w3
+        self.token = token
+        self.amount = amount
+        self.spender = spender
+
+    def InitNFTCheque(self):
+        pass
+
+    def CashOutNFTCheque(self):
+        pass
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+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

@@ -0,0 +1,27 @@
+
+import anchorpy
+from anchorpy import Idl, Provider, Wallet
+from shadowPaySDK.interface.sol import SOL
+from solders.keypair import Keypair
+import solana.constants as constants
+import solana.constants as sol_constants
+import spl.token.constants as spl_constants
+
+
+
+class SOLCheque:
+        def __init__(self, rpc_url: str = "https://api.mainnet-beta.solana.com", keystore: Wallet = None):
+            self.rpc_url = rpc_url
+            self.keystore = keystore
+            self.provider = Provider(self.rpc_url, self.keystore)
+            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))
+
+              return pubkey
+        
+
+
+
+  

shadowPaySDK/types/__init__.py

@@ -0,0 +1,4 @@
+from .EVMcheque import Cheque
+from .SOLcheque import SOLCheque
+
+__all__ = ['Cheque', 'SOLCheque']