Jayke770 · May 9, 2023 08:56 · May 9, 2023
diff --git a/ton.py b/ton.py
@@ -0,0 +1,123 @@
+from abc import ABC, abstractmethod
+import asyncio
+import aiohttp
+import base64
+from ton.sync import TonlibClient
+from tvm_valuetypes import serialize_tvm_stack
+from tonsdk.contract.wallet import WalletVersionEnum, Wallets, mnemonic_to_wallet_key
+from tonsdk.utils import bytes_to_b64str, from_nano, to_nano,  TonCurrencyEnum, Address, b64str_to_bytes
+from tonsdk.crypto import mnemonic_new
+from tonsdk.provider import ToncenterClient, SyncTonlibClient, prepare_address, address_state
+from tonsdk.boc import Cell
+from tonsdk.contract.token.ft import JettonWallet
+wallet_version = WalletVersionEnum.v3r1
+workchain = 0
+
+class AbstractTonClient(ABC):
+    @abstractmethod
+    def _run(self, to_run, *, single_query=True):
+        raise NotImplemented
+
+    def get_address_information(self, address: str,
+                                currency_to_show: TonCurrencyEnum = TonCurrencyEnum.ton):
+        return self.get_addresses_information([address], currency_to_show)[0]
+
+    def get_addresses_information(self, addresses,
+                                  currency_to_show: TonCurrencyEnum = TonCurrencyEnum.ton):
+        if not addresses:
+            return []
+
+        tasks = []
+        for address in addresses:
+            address = prepare_address(address)
+            tasks.append(self.provider.raw_get_account_state(address))
+
+        results = self._run(tasks, single_query=False)
+
+        for result in results:
+            result["state"] = address_state(result)
+            if "balance" in result:
+                if int(result["balance"]) < 0:
+                    result["balance"] = 0
+                else:
+                    result["balance"] = from_nano(
+                        int(result["balance"]), currency_to_show)
+
+        return results
+
+    def seqno(self, addr: str):
+        addr = prepare_address(addr)
+        result = self._run(self.provider.raw_run_method(addr, "seqno", []))
+
+        if 'stack' in result and ('@type' in result and result['@type'] == 'smc.runResult'):
+            result['stack'] = serialize_tvm_stack(result['stack'])
+
+        return result
+
+    def send_boc(self, boc: Cell):
+        return self._run(self.provider.raw_send_message(boc))
+
+
+class TonCenterTonClient(AbstractTonClient):
+    def __init__(self):
+        self.loop = asyncio.get_event_loop()
+        self.provider = ToncenterClient(base_url="https://testnet.toncenter.com/api/v2/",
+                                        api_key="")
+
+    def _run(self, to_run, *, single_query=True):
+        try:
+            return self.loop.run_until_complete(
+                self.__execute(to_run, single_query))
+
+        except Exception:
+            raise
+
+    async def __execute(self, to_run, single_query):
+        timeout = aiohttp.ClientTimeout(total=5)
+
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            if single_query:
+                to_run = [to_run]
+
+            tasks = []
+            for task in to_run:
+                tasks.append(task["func"](
+                    session, *task["args"], **task["kwargs"]))
+
+            return await asyncio.gather(*tasks)
+
+
+client = TonCenterTonClient()
+
+
+def generateWallet():
+    wallet_mnemonics = mnemonic_new()
+    _mnemonics, _pub_k, _priv_k, wallet = Wallets.from_mnemonics(
+        wallet_mnemonics, wallet_version, workchain)
+    query = wallet.create_init_external_message()
+    base64_boc = bytes_to_b64str(query["message"].to_boc(False))
+    print(base64_boc)
+   # client.send_boc(base64_boc)
+    return ({"mnemonic": _mnemonics, "publicKey": _pub_k, "privateKey": _priv_k, "address": wallet.address.to_string(True, True, True)})
+
+
+def getBalance(address):
+    wallet = client.get_address_information(address)
+    return wallet['balance']
+
+
+def sendTon(mnemonics, receiver, amount):
+    _mnemonics, _pub_k, _priv_k, wallet = Wallets.from_mnemonics(
+        mnemonics=mnemonics, version=wallet_version, workchain=workchain)
+    walletInfo = client.get_address_information(
+        wallet.address.to_string(True, True, True))
+    tx = wallet.create_transfer_message(
+        to_addr=receiver,
+        amount=to_nano(amount, 'ton'),
+        seqno=0,
+        payload=JettonWallet().create_transfer_body(
+            Address(receiver),
+            to_nano(amount, "ton")
+        ))
+    boc = bytes_to_b64str(tx['message'].to_boc(False))
+    client.send_boc(boc)
No results found