示例#1
0
 def unwraptx(duco_username, recipient, amount, private_key, public_key):
     txn = wduco.functions.initiateWithdraw(
         duco_username, recipient, int(float(amount) * 10**6)).with_owner(
             PublicKey(PrivateKey(bytes.fromhex(
                 wrapper_public_key)))).fee_limit(5_000_000).build().sign(
                     PrivateKey(bytes.fromhex(wrapper_private_key)))
     feedback = txn.broadcast().wait()
     return feedback
示例#2
0
    def balance_of(self, address):

        if self.network_type == 'mainnet':
            key = PrivateKey()
        elif self.network_type == 'testnet':
            key = PrivateKeyTestnet()
        else:
            raise Exception(
                f'network_type not in [mainnet, testnet], value={self.network_type}'
            )

        key._address = address
        return self.to_human_format_amount(key.get_balance())
示例#3
0
def transferToken():
    # cttAddr = ''

    _from = request.form.get('from_address')
    _to = request.form.get('to_address')
    _privKey = request.form.get('private_key')
    _amount = request.form.get('amount')
    _fee_limit = request.form.get('fee_limit', 20)

    try:
        _amount = to_sun(_amount)
        _fee_limit = to_sun(_fee_limit)

        if _amount <= 0:
            raise Exception('转账金额需大于0')
        if not is_address(_from):
            raise Exception('from 地址格式不正确')
        if not is_address(_to):
            raise Exception('to 地址格式不正确')

        client = Tron()
        priv_key = PrivateKey(bytes.fromhex(_privKey))
        contract = client.get_contract(cttAddr)
        # print('Balance', contract.functions.balanceOf(_from))
        txn = (
            contract.functions.transfer(_to, _amount).with_owner(
                _from).fee_limit(_fee_limit).build().sign(priv_key)
            # .inspect()
            .broadcast())
        return jsonify({"data": txn, "code": 200, "msg": "TOKEN交易成功"})
    except Exception as e:
        return jsonify({"data": None, "code": 500, "msg": str(e)})
示例#4
0
async def test_async_contract_create():
    # TGQgfK497YXmjdgvun9Bg5Zu3xE15v17cu
    priv_key = PrivateKey(
        bytes.fromhex(
            "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")
    )
    async with AsyncTron(network='nile') as client:
        bytecode = "608060405234801561001057600080fd5b5060c78061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea2646970667358221220c8daade51f673e96205b4a991ab6b94af82edea0f4b57be087ab123f03fc40f264736f6c63430006000033"
        abi = [{
            "inputs": [],
            "name":
            "get",
            "outputs": [{
                "internalType": "uint256",
                "name": "retVal",
                "type": "uint256"
            }],
            "stateMutability":
            "view",
            "type":
            "function",
        }]

        cntr = AsyncContract(name="SimpleStore", bytecode=bytecode, abi=abi)

        txb = client.trx.deploy_contract('TGQgfK497YXmjdgvun9Bg5Zu3xE15v17cu',
                                         cntr).fee_limit(1_000_000)
        txn = await txb.build()
        txn = txn.sign(priv_key).inspect()
        txn_ret = await txn.broadcast()

        print(txn_ret)
        result = await txn_ret.wait()
        print(result)
        print('Created:', result['contract_address'])
示例#5
0
def test_client_get_contract():
    client = Tron()
    priv_key = PrivateKey(
        bytes.fromhex(
            "ebf7c9cad1ca710553c22669fd3c7c70832e7024c1a32da69bbc5ad19dcc8992")
    )
    """
    txn = (
        client.trx.asset_issue(
            "TGxv9UXRNMh4E6b33iuH1pqJfBffz6hXnV", "BTCC", 1_0000_0000_000000, url="https://www.example.com"
        )
        .memo("test issue BTCC coin")
        .fee_limit(0)
        .build()
        .inspect()
        .sign(priv_key)
        # .broadcast()
    )

    print(txn)
    """

    # print(client.get_account_permission("TGxv9UXRNMh4E6b33iuH1pqJfBffz6hXnV"))

    # very old address, of mainnet
    # print(client.get_account_resource("TTjacDH5PL8hpWirqU7HQQNZDyF723PuCg"))
    # "TGj1Ej1qRzL9feLTLhjwgxXF4Ct6GTWg2U"))

    cntr = client.get_contract("TMDRdYAcXbQDajbGFy4rgXcNLYswuYsfk1")
    print(cntr)

    print(cntr.abi)
    # print(client.get_contract("TTjacDH5PL8hpWirqU7HQQNZDyF723PuCg"))

    cntr.functions.name()
示例#6
0
async def test_async_manual_client():
    from httpx import AsyncClient, Timeout, Limits
    from tronpy.providers.async_http import AsyncHTTPProvider
    from tronpy.defaults import CONF_NILE

    _http_client = AsyncClient(limits=Limits(max_connections=100,
                                             max_keepalive_connections=20),
                               timeout=Timeout(timeout=10, connect=5, read=5))
    provider = AsyncHTTPProvider(CONF_NILE, client=_http_client)
    client = AsyncTron(provider=provider)

    priv_key = PrivateKey(
        bytes.fromhex(
            "8888888888888888888888888888888888888888888888888888888888888888")
    )
    txb = (client.trx.transfer("TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3",
                               "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA",
                               1_000).memo("test memo").fee_limit(1_000_000))
    txn = await txb.build()
    txn_ret = await txn.sign(priv_key).broadcast()

    print(txn_ret)
    print(await txn_ret.wait())

    # must call .close at end to release connections
    await client.close()
示例#7
0
async def test_async_trc20_transfer():
    priv_key = PrivateKey(
        bytes.fromhex(
            "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee")
    )
    async with AsyncTron(network='nile') as client:
        contract = await client.get_contract(
            'THi2qJf6XmvTJSpZHc17HgQsmJop6kb3ia')
        print(
            'Balance', await
            contract.functions.balanceOf('TGQgfK497YXmjdgvun9Bg5Zu3xE15v17cu'))
        txb = await contract.functions.transfer(
            'TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA', 1_000)
        txb = txb.with_owner('TGQgfK497YXmjdgvun9Bg5Zu3xE15v17cu').fee_limit(
            5_000_000)
        txn = await txb.build()
        txn = txn.sign(priv_key).inspect()
        txn_ret = await txn.broadcast()

        print(txn)
        # wait
        receipt = await txn_ret.wait()
        print(receipt)
        if 'contractResult' in receipt:
            print(
                'result:',
                contract.functions.transfer.parse_output(
                    receipt['contractResult'][0]))

        # result
        print(await txn_ret.result())
示例#8
0
def transferTrx():
    _from = request.form.get('from_address')
    _to = request.form.get('to_address')
    _privKey = request.form.get('private_key')
    _amount = request.form.get('amount')

    try:
        _amount = to_sun(_amount)

        if _amount <= 0:
            raise Exception('转账金额需大于0')
        if not is_address(_from):
            raise Exception('from 地址格式不正确')
        if not is_address(_to):
            raise Exception('to 地址格式不正确')

        client = Tron()

        priv_key = PrivateKey(bytes.fromhex(_privKey))

        txn = (
            client.trx.transfer(_from, _to, _amount).memo("psex").build()
            # .inspect()
            .sign(priv_key).broadcast())
        return jsonify({"data": txn, "code": 200, "msg": "TRX交易成功"})
    except Exception as e:
        return jsonify({"data": None, "code": 500, "msg": str(e)})
示例#9
0
 def confirmunwraptx(duco_username, recipient, amount):
     txn = wduco.functions.confirmWithdraw(
         duco_username, recipient, int(float(amount) * 10**6)).with_owner(
             wrapper_public_key).fee_limit(5_000_000).build().sign(
                 PrivateKey(bytes.fromhex(wrapper_private_key)))
     txn = txn.broadcast()
     print("Sent confirm tx to tron network")
     return feedback
示例#10
0
 def wraptx(duco_username, address, amount):
     print("Tron wrapper called !")
     txn = wduco.functions.wrap(
         address, duco_username, int(float(amount) * 10**6)).with_owner(
             wrapper_public_key).fee_limit(5_000_000).build().sign(
                 PrivateKey(bytes.fromhex(wrapper_private_key)))
     txn = txn.broadcast()
     print("Sent wrap tx to TRON network")
     feedback = txn.wait()
     return feedback
示例#11
0
文件: tron.py 项目: YazdanRa/ad_bot
 def generate_address(self, priv_key=None) -> dict:
     """Generate a random address."""
     if priv_key is None:
         priv_key = PrivateKey.random()
     return {
         "base58check_address": priv_key.public_key.to_base58check_address(),
         "hex_address": priv_key.public_key.to_hex_address(),
         "private_key": priv_key.hex(),
         "public_key": priv_key.public_key.hex(),
     }
示例#12
0
    def sendTo(self, address):
        client = Tron()
        priv_key = PrivateKey(bytes.fromhex("YOUR_PRIVATE_KEY"))
        txn = (
            client.trx.transfer("TTfsJKVRDmFXRSYtp2QTGwEzjZvuWe7Fmj", address,
                                1)  # 1 is 0.000001 tron
            .memo("sending using tronpy").build().inspect().sign(
                priv_key).broadcast())

        print(txn)
        print(txn.wait())
示例#13
0
def test_signature_sign(signature: Signature, raw_data: bytes, txid: bytes):
    priv_key = PrivateKey.fromhex(
        "0000000000000000000000000000000000000000000000000000000000000001"
    )

    sig = priv_key.sign_msg(raw_data)
    pub_key = sig.recover_public_key_from_msg(raw_data)
    assert priv_key.public_key == pub_key

    sig = priv_key.sign_msg_hash(txid)
    pub_key = sig.recover_public_key_from_msg_hash(txid)
    assert priv_key.public_key == pub_key
示例#14
0
    def transfer(self, from_pri_key, to_address, human_format_amount, params):
        from_address = self.chain_client.pri_key_to_address(from_pri_key)
        priv_key = PrivateKey(bytes.fromhex(from_pri_key))
        currency_format_amount = self.to_currency_format_amount(
            human_format_amount)
        currency_format_amount = int(float(currency_format_amount))
        txn = (self.get_contract().functions.transfer(
            to_address, currency_format_amount).with_owner(
                from_address).build().sign(priv_key))

        ret = txn.broadcast()

        return ret['txid']
示例#15
0
    def transfer(self, from_pri_key, to_address, human_format_amount, params):
        decimals = 6
        from_address = self.chain_client.pri_key_to_address(from_pri_key)
        priv_key = PrivateKey(bytes.fromhex(from_pri_key))

        tron = self.chain_client.get_lib_client()
        currency_format_amount = int(float(human_format_amount) * 10**decimals)
        txn = (tron.trx.transfer(
            from_address, to_address,
            currency_format_amount).build().inspect().sign(
                priv_key).broadcast())
        ret = txn.wait()
        return ret['id']
示例#16
0
def test_client():
    client = Tron(network='nile')

    print(client)
    priv_key = PrivateKey(
        bytes.fromhex(
            "8888888888888888888888888888888888888888888888888888888888888888")
    )

    txn = (client.trx.transfer(
        "TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3",
        "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA",
        1_000).memo("test memo").fee_limit(100_000_000).build().inspect().sign(
            priv_key).broadcast())

    print(txn)
示例#17
0
def test_client_transfer_trc10():
    client = Tron(network='nile')

    priv_key = PrivateKey(
        bytes.fromhex(
            "ebf7c9cad1ca710553c22669fd3c7c70832e7024c1a32da69bbc5ad19dcc8992")
    )

    txn = (client.trx.asset_transfer(
        "TGxv9UXRNMh4E6b33iuH1pqJfBffz6hXnV",
        "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA",
        1_000000,
        token_id=1000047).memo("test transfer coin").fee_limit(
            0).build().inspect().sign(priv_key).broadcast())

    print(txn)
示例#18
0
    def trans_trx(key,tplayer,to_add,to_num,memo):
        # trx转账
        client = Tron()
        priv_key = PrivateKey(bytes.fromhex(key))
        txn = (
            client.trx.transfer(tplayer, to_add, int(to_num * 1000000))
                .memo(memo)
                .build()
                .inspect()
                .sign(priv_key)
                .broadcast()
        )
        print(txn)
        # > {'result': True, 'txid': '5182b96bc0d74f416d6ba8e22380e5920d8627f8fb5ef5a6a11d4df030459132'}

        ok=txn.wait()
        return ok
示例#19
0
async def test_async_client():
    async with AsyncTron(network='nile') as client:
        print(client)
        priv_key = PrivateKey(
            bytes.fromhex(
                "8888888888888888888888888888888888888888888888888888888888888888"
            ))

        txb = (client.trx.transfer(
            "TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3",
            "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA",
            1_000).memo("test memo").fee_limit(100_000_000))
        txn = await txb.build()
        txn.inspect()
        txn_ret = await txn.sign(priv_key).broadcast()

        print(txn_ret)
        print(await txn_ret.wait())
示例#20
0
async def test_async_client_sign_offline():
    async with AsyncTron(network='nile') as client:
        priv_key = PrivateKey(
            bytes.fromhex(
                "8888888888888888888888888888888888888888888888888888888888888888"
            ))
        tx = await client.trx.transfer(
            "TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3",
            "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA",
            1).memo("test memo").fee_limit(100_000_000).build()
        tx_j = tx.to_json()
        # offline
        tx_offline = await AsyncTransaction.from_json(
            tx_j)  # tx_offline._client is None so it's offline
        tx_offline.sign(priv_key)
        tx_j2 = tx_offline.to_json()
        # online
        tx_2 = await AsyncTransaction.from_json(tx_j2, client=client)
        await tx_2.broadcast()
示例#21
0
    def trc2_trans(to_con,key,tplayer,to_add,to_num,trc20_decimals):
        client = Tron()
        contract = client.get_contract(to_con)
        priv_key = PrivateKey(bytes.fromhex(key))

        txn = (
            contract.functions.transfer(to_add, int(to_num * (10 ** trc20_decimals)))
                .with_owner(tplayer)
                .fee_limit(1_000_000)
                .build()
                .sign(priv_key)
                .inspect()
                .broadcast()
        )

        # wait
        ok = txn.wait()
        print("结果", ok)
        return ok
示例#22
0
文件: tron.py 项目: YazdanRa/ad_bot
    def sign(self, priv_key: PrivateKey) -> "Transaction":
        """Sign the transaction with a private key."""

        assert self.txid, "txID not calculated"

        if self._permission is not None:
            addr_of_key = priv_key.public_key.to_hex_address()
            for key in self._permission["keys"]:
                if key["address"] == addr_of_key:
                    break
            else:
                raise BadKey(
                    "provided private key is not in the permission list",
                    "provided {}".format(priv_key.public_key.to_base58check_address()),
                    "required {}".format(self._permission),
                )
        sig = priv_key.sign_msg_hash(bytes.fromhex(self.txid))
        self._signature.append(sig.hex())
        return self
示例#23
0
def test_client_update_tx():
    client = Tron(network='nile')
    priv_key = PrivateKey(
        bytes.fromhex(
            "8888888888888888888888888888888888888888888888888888888888888888")
    )
    tx: Transaction = client.trx.transfer(
        "TJzXt1sZautjqXnpjQT4xSCBHNSYgBkDr3",
        "TVjsyZ7fYF3qLF6BQgPmTEZy1xrNNyVAAA",
        1).memo("test memo").fee_limit(100_000_000).build()
    tx.sign(priv_key)
    tx.broadcast()
    tx_id = tx.txid
    # update and transfer again
    time.sleep(0.01)
    tx.update()
    assert tx_id != tx.txid
    assert tx._signature == []
    tx.sign(priv_key)
    tx.broadcast()
示例#24
0
    def trc10_trans(key,tplayer,to_add,to_num,token_ids,token_pre,memo):
        # trc10转账
        client = Tron()
        priv_key = PrivateKey(bytes.fromhex(key))

        txn = (
            client.trx.asset_transfer(
                tplayer, to_add, int(to_num * (10 ** token_pre)), token_id=token_ids
            )
                .memo(memo)
                .fee_limit(0)
                .build()
                .inspect()
                .sign(priv_key)
                .broadcast()
        )

        print(txn)
        ok = txn.wait()
        return ok
示例#25
0
def test_contract_create():
    # TGQgfK497YXmjdgvun9Bg5Zu3xE15v17cu
    priv_key = PrivateKey(bytes.fromhex("eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"))
    client = Tron(network='nile')

    bytecode = "608060405234801561001057600080fd5b5060c78061001f6000396000f3fe6080604052348015600f57600080fd5b506004361060325760003560e01c806360fe47b11460375780636d4ce63c146062575b600080fd5b606060048036036020811015604b57600080fd5b8101908080359060200190929190505050607e565b005b60686088565b6040518082815260200191505060405180910390f35b8060008190555050565b6000805490509056fea2646970667358221220c8daade51f673e96205b4a991ab6b94af82edea0f4b57be087ab123f03fc40f264736f6c63430006000033"
    abi = [
        {
            "inputs": [],
            "name": "get",
            "outputs": [{"internalType": "uint256", "name": "retVal", "type": "uint256"}],
            "stateMutability": "view",
            "type": "function",
        }
    ]

    cntr = Contract(name="SimpleStore", bytecode=bytecode, abi=abi)

    # https://developers.tron.network/docs/setting-a-fee-limit-on-deployexecution
    # The maximum limit is 1000 TRX, or 1e9 SUN. Setting it to a value larger than 1e9 will produce an error.
    # When deploying large contracts or running complex functions, this limit may need to be increased up to 1000 TRX. However, check out timeouts, infinite loops, illegal operations, and non-existent account transfer sections are why setting a higher limit may sometimes be bad practice.

    # The maximum limit is 1000 TRX, or 1e9 SUN. Setting it to a value larger than 1e9 will produce an error.
    # feeLimit: 1e9,  // Set fee limit

    txn = (
        client.trx.deploy_contract('TGQgfK497YXmjdgvun9Bg5Zu3xE15v17cu', cntr)
        .fee_limit(1000000000)
        .build()
        .sign(priv_key)
        .inspect()
        .broadcast()
    )
    print(txn)
    result = txn.wait()
    print(result)
    print('Created:', result['contract_address'])
示例#26
0
def test_key_convert():
    priv_key = PrivateKey.fromhex(
        "0000000000000000000000000000000000000000000000000000000000000001"
    )
示例#27
0
def test_private_key():
    with pytest.raises(BadKey):
        PrivateKey(
            bytes.fromhex("0000000000000000000000000000000000000000000000000000000000000000")
        )
示例#28
0
 def pri_key_to_address(self,
                        pri_key):
     tron = self.get_lib_client()
     ret = tron.generate_address(PrivateKey.fromhex(pri_key))
     return ret['base58check_address']
示例#29
0
 def get_address_from_passphrase(self, passphrase: str) -> dict:
     """Get an address from a passphrase, compatiable with `wallet/createaddress`."""
     priv_key = PrivateKey.from_passphrase(passphrase.encode())
     return self.generate_address(priv_key)
示例#30
0
                    wss_conn.send(bytes("CLOSE", encoding="utf8"))
                except:
                    pass
                os._exit(0)

            elif command == "wrapperconf":  # wrapper config
                config.read(RESOURCES_DIR + "/CLIWallet_config.cfg")
                if (not config["wrapper"]["use_wrapper"] == "true"
                        and tronpy_installed):
                    print(Style.RESET_ALL + Fore.WHITE +
                          getString("select_option"))
                    try:
                        choice = int(input(getString("choice_input_wrapper")))

                        if choice <= 1:
                            priv_key = str(PrivateKey.random())
                            pub_key = PrivateKey(bytes.fromhex(
                                priv_key)).public_key.to_base58check_address()
                            print(getString("how_encrypt_private_key"))

                            incorrect_value = True
                            while incorrect_value:
                                try:
                                    encryption_choice = int(
                                        input(getString("encryption_choice")))
                                    incorrect_value = False
                                except ValueError:
                                    print(getString("value_not_numeric"))
                                    incorrect_value = True

                                if encryption_choice <= 1: