api info token

.env.dist

@@ -1,4 +1,5 @@
-TON_CONSOLE__API_KEY = ""
+TON_CONSOLE__API_KEY = "AFVDINKN6H4UXLAAAAAFQNNUC6P2JZHNZALNC6LVMWGUASBBI372VHRNRSUB7NGQCSB5BQA"
+TON__HOST_URL = "https://toncenter.com"
 
 TON__TON_CONTRACT_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c"
 TON__TGR_CONTRACT_ADDRESS = "EQAvDfWFG0oYX19jwNDNBBL1rKNT9XfaGP9HyTb5nb2Eml6y"
@@ -10,18 +11,19 @@ STON_FI__PROXY_TON_ADDRESS = "EQCM3B12QK1e4yZSf8GtBRT0aLMNyEsBc_DhVfRRtOEffLez"
 STON_FI__TON_CONTRACT_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c"
 STON_FI__ROUTER_ADDRESS = "EQB3ncyBUTjZUA5EnFKR5_EnOMI9V1tTEAAPaiU71gc4TiUt"
 
+
 SWAP__FEE_PERCENT = 0.2
 SWAP__TGR_CASHBACK_PERCENT = 0.1
-SWAP__TON_FEE_ADDRESS = ""
+SWAP__TON_FEE_ADDRESS = "UQDlCpEgRM4Zxh39DaPoSI1gZx0XFx8UlHdjZBYRsVP71cUq"
 
 DATABASE__DEV_URL_ASYNC = "sqlite+aiosqlite:///./database.db"
 DATABASE__DEV_URL_SYNC = "sqlite:///./database.db"
 DATABASE__DEV_MODE = True
 
-SECRET = ""
-ALGORITHM = ""
+SECRET = "123456"
+ALGORITHM = "HS256"
 
-JWT__COOKIE_SECURE = False
+JWT__COOKIE_SECURE = True
 
 SERVER__DOMAIN = ""
-SERVER__CORS_ALLOW_ORIGINS = []
+SERVER__CORS_ALLOW_ORIGINS = ["http://localhost:3000","http://192.168.0.56:3000","http://192.168.1.153:3000"]

Dockerfile

@@ -0,0 +1,17 @@
+# 
+FROM python:3.10
+
+# 
+WORKDIR /code
+
+# 
+COPY ./requirements.txt /code/requirements.txt
+
+# 
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# 
+COPY ./src /code/src
+
+# 
+CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "80"]

docker-compose.yml

@@ -0,0 +1,14 @@
+version: '3.8'
+
+services:
+  server:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    volumes:
+      - .:/ton-backend/
+    command: uvicorn src.server:app --reload --host 0.0.0.0 --port 8000
+    env_file:
+      - ./.env.dist
+    ports:
+      - 8000:8000

src/api/v1/ton/__init__.py

@@ -1,7 +1,8 @@
 from fastapi import FastAPI
 
-from .schemas import GetJettonsBalancesResponse
+from .schemas import GetJettonsBalancesResponse, TokenInfoResponse
 from .wallets import get_jettons_balances_endpoint
+from .token import get_info_token_endpoint
 
 
 def register_routes(app: FastAPI):
@@ -11,3 +12,10 @@ def register_routes(app: FastAPI):
         response_model=GetJettonsBalancesResponse,
         methods=["GET"],
     )
+
+    app.add_api_route(
+        path="/api/v1/token/get_token_info",
+        endpoint=get_info_token_endpoint,
+        response_model=TokenInfoResponse,
+        methods=["GET"],
+    )

src/api/v1/ton/schemas.py

@@ -1,6 +1,7 @@
 from typing import Dict
 from pydantic import BaseModel
 from src.utils.address import ValidatedAddress
+from src.ton.schemas import TokenInfo
 
 
 class GetJettonsBalancesRequest(BaseModel):
@@ -9,3 +10,7 @@ class GetJettonsBalancesRequest(BaseModel):
 
 class GetJettonsBalancesResponse(BaseModel):
     balances: Dict[ValidatedAddress, int]
+
+
+class TokenInfoResponse(BaseModel):
+    data: TokenInfo

src/api/v1/ton/token.py

@@ -0,0 +1,14 @@
+from fastapi import Depends
+
+from src.config import config
+from src.ton.ton_api import get_info_token
+
+from .schemas import TokenInfoResponse
+
+
+async def get_info_token_endpoint(
+    address: str
+):
+    info_token = await get_info_token(address= address)
+    response = TokenInfoResponse(data=info_token)
+    return response

src/config.py

@@ -34,6 +34,7 @@ class Ton(BaseSettings):
     tgr_contract_address: str
     fnz_contract_address: str
     scale_contract_address: str
+    host_url: str
 
 
 class Swap(BaseSettings):

src/dex/ston_fi_contracts/router.py

@@ -217,7 +217,6 @@ async def get_pool_data(
         response = await self.tonapi_client.blockchain.execute_get_method(
             account_id=pool_address.to_string(),
             method_name="get_pool_data",
-            args=[],
         )
 
         reserve0 = int(response.stack[0].num, 16)
@@ -258,10 +257,10 @@ async def get_expected_tokens(
         token0_amount: int,
         token1_amount: int,
     ) -> int:
-        response = await self.tonapi_client.blockchain.execute_get_method(
+        response = await self.tonapi_client.blockchain.execute_get_wallets_method(
             account_id=pool_address,
             method_name="get_expected_tokens",
-            args=[
+            arggs=[
                 f"{token1_amount}",
                 f"{token0_amount}",
             ],
@@ -276,7 +275,6 @@ async def get_lp_account_data(
         response = await self.tonapi_client.blockchain.execute_get_method(
             account_id=lp_account_address,
             method_name="get_lp_account_data",
-            args=[],
         )
 
         token0_address = parse_address_from_bytes(

src/ton/schemas.py

@@ -0,0 +1,64 @@
+from typing import Any
+from dataclasses import dataclass
+import json
+@dataclass
+class Data:
+    image: str
+    name: str
+    symbol: str
+    description: str
+    decimals: str
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Data':
+        _image = str(obj.get("image"))
+        _name = str(obj.get("name"))
+        _symbol = str(obj.get("symbol"))
+        _description = str(obj.get("description"))
+        _decimals = str(obj.get("decimals"))
+        return Data(_image, _name, _symbol, _description, _decimals)
+
+@dataclass
+class JettonContent:
+    type: str
+    data: Data
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'JettonContent':
+        _type = str(obj.get("type"))
+        _data = Data.from_dict(obj.get("data"))
+        return JettonContent(_type, _data)
+
+@dataclass
+class Result:
+    total_supply: float
+    mintable: bool
+    admin_address: str
+    jetton_content: JettonContent
+    jetton_wallet_code: str
+    contract_type: str
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'Result':
+        _total_supply = float(obj.get("total_supply"))
+        _mintable = True
+        _admin_address = str(obj.get("admin_address"))
+        _jetton_content = JettonContent.from_dict(obj.get("jetton_content"))
+        _jetton_wallet_code = str(obj.get("jetton_wallet_code"))
+        _contract_type = str(obj.get("contract_type"))
+        return Result(_total_supply, _mintable, _admin_address, _jetton_content, _jetton_wallet_code, _contract_type)
+
+@dataclass
+class TokenInfo:
+    ok: bool
+    result: Result
+
+    @staticmethod
+    def from_dict(obj: Any) -> 'TokenInfo':
+        _ok = obj.get("ok")
+        _result = Result.from_dict(obj.get("result"))
+        return TokenInfo(_ok, _result)
+
+# Example Usage
+# jsonstring = json.loads(myjsonstring)
+# token = TokenInfo.from_dict(jsonstring)

src/ton/ton_api.py

@@ -0,0 +1,23 @@
+from src.config import config
+from src.ton.schemas import TokenInfo
+import httpx
+import json
+import logging
+logger = logging.getLogger("ton-debug")
+
+async def get_info_token(address: str) -> TokenInfo:
+        """
+        Get token data info.
+        """
+        timeout = httpx.Timeout(120)
+        try:
+            async with httpx.AsyncClient(timeout=timeout) as session:
+                session: httpx.AsyncClient
+                params = {"address":address}
+                url = f"{config.ton.host_url}/api/v2/getTokenData"
+                response = await session.request("GET", url=url, params= params,headers={"Content-Type":"application/json"})
+                jsonStr = response.json()
+                resData = json.loads(json.dumps(jsonStr))
+                return TokenInfo.from_dict(resData)
+        except httpx.LocalProtocolError as err:
+            logger.error(err)

src/ton/utils.py

@@ -1,9 +1,10 @@
 from pytonapi import AsyncTonapi
 from tonsdk.boc import Cell, Slice, begin_cell
 from tonsdk.utils import Address, b64str_to_bytes, bytes_to_b64str
-
 from src.ton.tonapi_client_factory import TonapiClientFactory
 
+import logging
+logger = logging.getLogger("ton-debug")
 
 def get_address_cell(address: Address | str) -> Cell:
     if isinstance(address, str):
@@ -50,11 +51,14 @@ async def get_jetton_wallet_address(
         tonapi_client = TonapiClientFactory.get_tonapi_client()
 
     owner_wallet_address_hex = get_address_cell(owner_wallet_address)
-
-    response = await tonapi_client.blockchain.execute_get_method(
+
+    owner_wallet_address_hex_value = owner_wallet_address_hex.to_boc(False).hex()
+    logger.info("wallet address: " + owner_wallet_address_hex_value)
+
+    response = await tonapi_client.blockchain.execute_get_wallets_method(
         account_id=jetton_contract_address,
         method_name="get_wallet_address",
-        args=[owner_wallet_address_hex.to_boc(False).hex()],
+        arggs=[owner_wallet_address_hex_value],
     )
 
     wallet_address = parse_address_from_bytes(