Warum sollte ich eine Bestellung aufgeben?

Auf dem Kryptowährungsmarkt sind Handelsmöglichkeiten oft flüchtig, insbesondere Arbitragemöglichkeiten, die möglicherweise nur wenige Minuten bestehen. Wenn Sie sich auf manuelle Vorgänge verlassen, können Benutzer möglicherweise die beste Gelegenheit nicht rechtzeitig nutzen oder den besten Preis verpassen. Beispielsweise wurde USDe vor einiger Zeit aufgrund des Hackerangriffs auf Bybit entkoppelt, was zu starken Preisschwankungen führte. Zu diesem Zeitpunkt lag die annualisierte Rendite durch den Kauf und die Rücknahme von sUSDe bei über 300 %. Dieses Fenster mit hohen Erträgen ist in der Regel nur von sehr kurzer Dauer und es ist für den manuellen Handel schwierig, mit dem Marktrhythmus Schritt zu halten, ohne im Voraus Aufträge zu erteilen. Daher ist die Auftragserteilungsfunktion zu einem wichtigen Tool für Benutzer dezentraler Börsen (DEX) geworden, das die Transaktionseffizienz erheblich verbessert.

Die Prinzipien und Mängel von DEX-Aufträgen

Mehrere DEXs bieten Limit-Order-Funktionen, jeweils mit unterschiedlichen Implementierungen und Gebührenstrukturen. Nehmen Sie Cow Swap und Odos als Beispiele. Das Kernprinzip besteht darin, mithilfe der Aggregatorfunktion die Liquidität und Preise mehrerer DEXs in Echtzeit zu überwachen. Wenn der Marktpreis die Grenzbedingungen erfüllt, wird die Bestellung vom Abnehmer ausgelöst und der Smart Contract führt die Transaktion automatisch aus und zahlt die Gasgebühr. Cow speichert außerdem die Aufträge der Benutzer außerhalb der Kette, die dann von einer Gruppe dezentraler Knoten, den sogenannten „Solvers“, wettbewerbsmäßig abgeglichen, aber letztendlich in der Kette ausgeführt werden. Kurz gesagt: Obwohl GAS ausgenommen ist, können die zusätzlichen Gewinne, die durch die von diesen DEXs für Sie durchgeführten Transaktionen generiert werden, die GAS-Gebühren decken.

Dies wirft jedoch ein Problem auf: Wenn eine Ihrer Bestellungen zu einem Preis von 90 U aussteht und der Aggregator feststellt, dass der Preis einer bestimmten DEX auf 80 U gefallen ist, führt er die Transaktion für Sie aus. Ihre Bestellung wird schließlich zu einem Preis von 90 U ausgeführt, was einen Gewinn von 10 U generiert. Wie wird dieser Gewinn verteilt? Im tatsächlichen Betrieb handhaben es verschiedene Plattformen unterschiedlich. Am Beispiel von Cow Swap ist im Mechanismus klar festgelegt, dass, wenn der Ausführungspreis besser ist als der Limitpreis, der generierte Überschuss (also die 10U) zwischen der Plattform und dem Benutzer aufgeteilt wird, wobei Cow Swap 50 % erhält und der Benutzer die restlichen 50 %. Etwaige Überschüsse werden von Odos im Tresor deponiert. Im Wesentlichen wird Ihre Bestellung von der DEX-Börse risikofrei per Arbitrage abgewickelt.

Um Transaktionsgebühren zu sparen, handelt es sich bei DEX-Aufträgen außerdem um aggregierte Transaktionen, d. h. viele Transaktionen werden von Zeit zu Zeit zusammengefasst, und ETH hat einen Block von 12 Sekunden, was dazu führen wird, dass einige mögliche Gelegenheiten verpasst werden. Natürlich bietet DEX immer noch viele Vorteile, wie z. B. die Suche nach mehr Pfaden, Offline-Matching, GAS-Einsparungen usw., die für die meisten Benutzer ausreichend sind.

Vorteile der Auftragserteilung mit Ihrem eigenen Programm

Im Vergleich zur Abhängigkeit von den aggregierten Aufträgen von DEX bietet der direkte Handel über Smart Contracts einzigartige Vorteile. Erstens haben Benutzer die volle Kontrolle über die Auftragsausführungslogik und alle Einnahmen. Zweitens können Sie durch das Platzieren Ihrer eigenen Aufträge die Verpackungsverzögerung aggregierter Transaktionen vermeiden und schneller auf Marktveränderungen reagieren, insbesondere indem Sie bei hoher Volatilität innerhalb von 12 Sekunden Gelegenheiten nutzen. Darüber hinaus können benutzerdefinierte ausstehende Aufträge flexibel komplexe Bedingungen festlegen (wie z. B. Multi-Asset-Portfolio-Handel oder Stop-Profit und Stop-Loss), ohne durch die voreingestellten Funktionen der Plattform eingeschränkt zu sein. Dies erfordert jedoch bestimmte Programmierkenntnisse, und man muss die Gasgebühr selbst bezahlen. Außerdem können Sicherheitsrisiken in der Kette bestehen. Daher ist das Aufgeben eigener Bestellungen für fortgeschrittene Benutzer geeignet, die über gute technische Fähigkeiten verfügen und maximale Renditen anstreben.

Schutz privater Schlüssel

Wenn Sie Smart Contracts mit Ihren eigenen Programmen betreiben möchten, ist die Sicherheit Ihrer privaten Schlüssel zweifellos Ihr größtes Anliegen. Meine Lösung besteht darin, meinen privaten Schlüssel offline mit Python zu verschlüsseln und den verschlüsselten Text auf dem Server zu speichern, auf dem der Host läuft. Das entschlüsselte Passwort wird mit den Parametern des FMZ-Plattformroboters übergeben, und das Programm läuft auf dem Host, liest und entschlüsselt es (es kann nach dem Programmlauf gelöscht werden). Auf diese Weise gibt es selbst dann kein Problem, wenn Ihr Server gehackt wird. Sie müssen jedoch trotzdem darauf achten, dass Ihr FMZ-Konto nicht preisgegeben wird. Da es sich nur um einen netzwerkexternen Klartext handelt, ist die Sicherheit akzeptabel. Der spezifische Code ist wie folgt, der lokal netzunabhängig ausgeführt werden kann

from web3 import Web3  # Web3.py 是与以太坊区块链交互的Python库
import json  # 用于处理JSON数据
import time  # 用于设置时间间隔
import requests  # 用于发送HTTP请求
from cryptography.fernet import Fernet
import base64
import hashlib
from datetime import datetime
from hexbytes import HexBytes

def generate_key(password: str) -> bytes:
    """通过用户密码生成 AES 密钥"""
    return base64.urlsafe_b64encode(hashlib.sha256(password.encode()).digest())

def encrypt_private_key(private_key: str, password: str) -> str:
    """使用密码加密私钥"""
    key = generate_key(password)
    cipher = Fernet(key)
    return cipher.encrypt(private_key.encode()).decode()

def decrypt_private_key(encrypted_key: str, password: str) -> str:
    """使用密码解密私钥"""
    key = generate_key(password)
    cipher = Fernet(key)
    return cipher.decrypt(encrypted_key.encode()).decode()

def save_key_to_file(key, file_path):
    # 将加密密钥保存到txt文件
    with open(file_path, 'w') as file:
        file.write(key) 

def load_key_from_file(file_path):
    # 从txt文件读取加密密钥
    with open(file_path, 'r') as file:
        return str(file.read())

def main():
    encrypt_key = encrypt_private_key('my_private_key', 'password') # my_private_key是自己的私钥，password是自己设置的密码
    save_key_to_file(encrypt_key,'encrypt_key.txt')
    print("加密后的私钥", encrypt_key)
    decrypt_key = decrypt_private_key(load_key_from_file('encrypt_key.txt'), 'password')
        print("解密的私钥", decrypt_key)

Vorbereitung vor der ETH-Anbindung

Web3.py ist eine leistungsstarke Python-Bibliothek für die Interaktion mit dem Ethereum-Netzwerk. Installieren Sie es mit dem folgenden Befehl: pip install web3. Seine Funktion besteht darin, die Kommunikation zwischen Entwicklern und Ethereum-Knoten zu vereinfachen und Vorgänge wie das Abfragen von Guthaben, das Aufrufen von Smart Contracts und das Senden von Transaktionen zu unterstützen. Beispielsweise sind zum Überprüfen eines Kontostands nur wenige Codezeilen erforderlich, was Web3.py zu einem idealen Tool zum Erstellen von DApps oder zum Automatisieren von Transaktionen macht.

python
from web3 import Web3
w3 = Web3(Web3.HTTPProvider('你的RPC地址'))
balance = w3.eth.get_balance('0x某个地址')
print(w3.from_wei(balance, 'ether'))

RPC (Remote Procedure Call) ist eine vom Ethereum-Knoten bereitgestellte Kommunikationsschnittstelle, die mit der Blockchain interagiert, indem sie JSON-Anfragen über das HTTP- oder WebSocket-Protokoll sendet. Beispielsweise kann eth_blockNumber die neueste Blockhöhe abfragen. Aufgrund der hohen Kosten für den Betrieb eines lokalen Knotens verlassen sich Entwickler normalerweise auf RPC-Anbieter von Drittanbietern. Zu den üblichen Optionen gehören:

• Infura: MetaMask-Standarddienst, einfach zu verwenden, aber geringes kostenloses Kontingent (100.000 Anfragen pro Tag).
• Alchemy: Überlegene Leistung, hohes kostenloses Kontingent und Unterstützung für mehr Funktionen.
• QuickNode: Geeignet für hohe Leistungsanforderungen, aber eher auf zahlende Benutzer ausgerichtet.

from web3 import Web3
w3 = Web3(Web3.HTTPProvider('https://eth-mainnet.g.alchemy.com/v2/你的API密钥'))
print(w3.is_connected())

Es wird empfohlen, Alchemy zu verwenden. Im Vergleich zu Infura von MetaMask bietet Alchemy ein höheres kostenloses Kontingent. Nach der Registrierung können Sie die RPC-Adresse, z. B. https://eth-mainnet.g.alchemy.com/v2/Ihren API-Schlüssel, abrufen und zur Verwendung auf Web3.py konfigurieren.

Curve-Vertragsadresse und ABI

Am Beispiel des Crve-Pools von sDAI/sUSDe https://curve.fi/dex/ethereum/pools/factory-stable-ng-102/swap/ können Sie die Adressen der beiden Token und die Adresse des Pools leicht finden.

Die ABI definiert die Interaktion mit dem Vertrag und muss daher abgerufen werden. Den Vertrag finden Sie auf ethscan https://etherscan.io/address/0x167478921b907422f8e88b43c4af2b8bea278d3a#code. Sie können die ABI auf der Vertragsseite einsehen und direkt kopieren.

Verknüpfen Sie den Vertrag, um den Preis zu erhalten

Verknüpfen Sie zunächst das ETH-Wallet. Wenn Ihre Wallet-Adresse ausgedruckt wird, war der Vorgang erfolgreich.

def main():
    # 文件路径
    file_path = 'encrypted_key.txt'

    # 从文件中读取加密的私钥
    encrypted_private_key = load_key_from_file(file_path)
    private_key = decrypt_private_key(encrypted_private_key, Password) #Password为密码，定义为策略的参数
    web3 = Web3(Web3.HTTPProvider(HTTPProvider)) # HTTPProvider为RPC的链接，定义为参数
    account = web3.eth.account.from_key(private_key)
    address = account.address  # 获取账户的公开地址
    Log('链接账户', address)

Im Folgenden wird der Prozess zur Preisermittlung beschrieben. Ohne Berücksichtigung der GAS-Gebühr wird die aktuelle Investition von 100.000 SDAI nach einer Woche einen Gewinn von 335U erzielen. Es sieht vielleicht etwas kompliziert aus, ist aber eigentlich nicht schwer zu verstehen.

    # --------------- 合约设置 ---------------
    # Curve.fi sDAI/sUSDe 池合约地址和ABI
    pool_address = '0x167478921b907422F8E88B43C4Af2B8BEa278d3A'  # Curve池子的合约地址
    # 以下是简化的ABI，仅包含我们需要的函数
    pool_abi = json.loads('''[{"stateMutability":"view","type":"function","name":"get_dy","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"dx","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]}]''')
    # 创建池子合约对象
    pool_contract = web3.eth.contract(address=pool_address, abi=pool_abi)

    # ERC20 代币标准合约ABI
    erc20_abi = json.loads('''[
        {"constant":true,"inputs":[{"name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"name":"balance","type":"uint256"}],"type":"function"},
        {"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"success","type":"bool"}],"type":"function"},
        {"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"}
    ]''')

    sdai_address = '0x83F20F44975D03b1b09e64809B757c47f942BEeA'  # sDAI代币的合约地址
    susde_address = '0x9D39A5DE30e57443BfF2A8307A4256c8797A3497'  # sUSDE代币的合约地址
    # 池子中代币的索引
    SDAI_INDEX = 0  # sDAI代币在池子中的索引
    SUSDE_INDEX = 1  # sUSDE代币在池子中的索引
    # 创建代币合约对象
    sdai_contract = web3.eth.contract(address=sdai_address, abi=erc20_abi)
    susde_contract = web3.eth.contract(address=susde_address, abi=erc20_abi)
    SUSDE_PRICE = 1.1623 #这个价格是ethena官网价格，1周后可赎回
    SDAI_PRICE = 1.15 #sDAI是收益代币，价值会累计，目前价格1.15

    try:
        SDAI_DECIMALS = sdai_contract.functions.decimals().call()
        SUSDE_DECIMALS = susde_contract.functions.decimals().call()
    except:
        # 如果无法获取，假设为标准的18位精度
        SDAI_DECIMALS = 18
        SUSDE_DECIMALS = 18
    amount_in = 100000
    amount_out = pool_contract.functions.get_dy(
                    SDAI_INDEX,  # 输入代币索引
                    SUSDE_INDEX,  # 输出代币索引
                    int(amount_in *  10**SDAI_DECIMALS)   # 输入数量(wei)
                ).call()
    profit =  SUSDE_PRICE * amount_out / 10**SUSDE_DECIMALS -  amount_in * SDAI_PRICE
    Log(round(profit, 2), round(amount_out / 10**SUSDE_DECIMALS, 2))

Vollständiges Programm

Schließlich nutzen wir Polling, um kontinuierlich Preise zu ermitteln und eine Bestellung aufzugeben, wenn der erwartete Gewinn erreicht ist. Beachten Sie diesen CodeDies ist nur ein Beispielcode, verwenden Sie ihn nicht direktLeser können in der Praxis auf verschiedene Probleme stoßen, aber KI ist derzeit sehr leistungsfähig und kann grundsätzlich verschiedene Fragen beantworten. Sie kann auch direkt beim Schreiben von Code helfen. Der Code-Editor von FMZ integriert auch ChatGPT, das häufiger verwendet werden kann.

def execute_trade(amount_in, min_amount_out, direction):
    gas_price = web3.eth.gas_price
    index_in = SUSDE_INDEX
    index_out = SDAI_INDEX
    if direction == 'buy':
        index_in = SDAI_INDEX
        index_out = SUSDE_INDEX
    # 第二步：执行代币交换交易
    swap_tx = pool_contract.functions.exchange(
        index_in,  # 输入代币索引
        index_out,  # 输出代币索引
        int(amount_in*10**SDAI_DECIMALS),  # 输入数量
        int(min_amount_out*10**SUSDE_DECIMALS)  # 最小输出数量(考虑滑点)
    ).build_transaction({
        'from': address,  # 交易发送方
        'gas': 600000,  # gas限制
        'gasPrice': int(2*gas_price) ,
        'nonce': web3.eth.get_transaction_count(address),  # 获取新的nonce值
    })
    
    # 签名并发送交换交易
    signed_swap_tx = web3.eth.account.sign_transaction(swap_tx, private_key)
    swap_tx_hash = web3.eth.send_raw_transaction(signed_swap_tx.rawTransaction)
    
    Log(f"交换交易已提交，交易哈希: {swap_tx_hash.hex()}")

def get_buy_profit(amount_in):
    amount_out = pool_contract.functions.get_dy(
                    SDAI_INDEX,  # 输入代币索引
                    SUSDE_INDEX,  # 输出代币索引
                    int(amount_in *  10**SDAI_DECIMALS)   # 输入数量(wei)
                ).call()
    return  SUSDE_PRICE * amount_out / 10**SUSDE_DECIMALS -  amount_in * SDAI_PRICE, amount_out / 10**SUSDE_DECIMALS

def main():
    while True:
        try:
            sdai_balance = sdai_contract.functions.balanceOf(address).call() / 10**SDAI_DECIMALS
            susde_balance = susde_contract.functions.balanceOf(address).call() / 10**SUSDE_DECIMALS
            amount_in = 100000 #交易的DAI数量
            profit, amount_out = get_buy_profit(amount_in)
            LogStatus(f"SDAI数量：{sdai_balance}, SUSDE数量：{susde_balance}, 收益：{profit}")
            if profit > 1000 and sdai_balance > amount_in: #利润空间
                Log("\n开始执行SDAI->SUSDE交易...")
                execute_trade(amount_in, 0.999*amount_out, 'buy') #一定要设置滑点
            wait_time = 3  # 等待时间(秒)
            time.sleep(wait_time)
            
        except Exception as e:
            # 全局错误处理
            print(f"程序发生错误: {e}")
            print("60秒后重试...")
            time.sleep(60)  # 出错后等待更长时间

Risikohinweis

On-Chain-Operationen sind für Anfänger relativ riskant. Neben dem oben erwähnten Risiko des Verlusts privater Schlüssel gibt es verschiedene weitere Risiken:

• MEV-Roboter müssen bei der Ausführung von Transaktionen den Mindestausgangsbetrag min_amount_out festlegen, um auch im schlimmsten Fall Gewinne sicherzustellen, andernfalls werden sie von MEV ausgenutzt. Heute hat jemand 220.000 USDC verwendet, um sie auf Uniswap gegen nur 5272 USDT einzutauschen. Der Grund dafür war, dass amountOutMinimum auf 0 gesetzt war.
• Strategiefehler: Genau wie bei der Exchange-API wird häufig GAS verbraucht, wenn bei der On-Chain-Programmtransaktion ein Fehler auftritt.

Anfänger im On-Chain-Handel müssen die Grundlagen erlernen: Konzepte wie Gas, Slippage, MEV usw. verstehen. Beginnen Sie immer mit einem niedrigen Betrag und steigern Sie ihn nach oben. Überwachen Sie Transaktionen mit etwas wie Etherscan. Es ist besser, eine Gelegenheit zu verpassen, als zu riskieren, Ihr Kapital zu verlieren.