பிரதான உள்ளடக்கத்திற்குச் செல்

எத்தேரியத்தில் உங்கள் சொந்த AI வர்த்தக முகவரை உருவாக்குங்கள்

AI
வர்த்தகம்
ஏஜென்ட்
python
இடைநிலை
Ori Pomerantz
13 பிப்ரவரி, 2026
20 நிமிட வாசிப்பு

இந்த டுடோரியலில் ஒரு எளிய AI வர்த்தக முகவரை எவ்வாறு உருவாக்குவது என்பதை நீங்கள் கற்றுக்கொள்வீர்கள். இந்த முகவர் இந்தப் படிகளைப் பயன்படுத்தி வேலை செய்கிறது:

  1. ஒரு டோக்கனின் தற்போதைய மற்றும் கடந்த கால விலைகளையும், மற்ற சாத்தியமான தொடர்புடைய தகவல்களையும் படிக்கவும்
  2. இந்தத் தகவலுடன், அது எவ்வாறு தொடர்புடையதாக இருக்கலாம் என்பதை விளக்குவதற்கான பின்னணித் தகவலுடன் ஒரு வினவலை உருவாக்கவும்
  3. வினவலைச் சமர்ப்பித்து, கணிக்கப்பட்ட விலையைத் திரும்பப் பெறவும்
  4. பரிந்துரையின் அடிப்படையில் வர்த்தகம் செய்யவும்
  5. காத்திருந்து மீண்டும் செய்யவும்

இந்த முகவர் தகவலை எவ்வாறு படிப்பது, பயன்படுத்தக்கூடிய பதிலைத் தரும் வினவலாக மாற்றுவது, மற்றும் அந்தப் பதிலை எவ்வாறு பயன்படுத்துவது என்பதை நிரூபிக்கிறது. இவை அனைத்தும் ஒரு AI முகவருக்குத் தேவையான படிகள். இந்த முகவர் Python-இல் செயல்படுத்தப்படுகிறது, ஏனெனில் இது AI-இல் பயன்படுத்தப்படும் மிகவும் பொதுவான மொழியாகும்.

இதை ஏன் செய்ய வேண்டும்?

தானியங்கு வர்த்தக முகவர்கள், உருவாக்குநர்கள் (டெவலப்பர்கள்) ஒரு வர்த்தக உத்தியைத் தேர்ந்தெடுத்து செயல்படுத்த அனுமதிக்கின்றன. AI முகவர்கள் மேலும் சிக்கலான மற்றும் மாறும் வர்த்தக உத்திகளை அனுமதிக்கின்றன, உருவாக்குநர்கள் (டெவலப்பர்கள்) பயன்படுத்தக் கூட கருதாத தகவல் மற்றும் அல்காரிதம்களை இது சாத்தியமாகப் பயன்படுத்துகிறது.

கருவிகள்

இந்த டுடோரியல் மேற்கோள்கள் மற்றும் வர்த்தகத்திற்காக Python (opens in a new tab), Web3 நூலகம் (opens in a new tab) மற்றும் Uniswap v3 (opens in a new tab) ஆகியவற்றைப் பயன்படுத்துகிறது.

ஏன் Python?

AI-க்கு மிகவும் பரவலாகப் பயன்படுத்தப்படும் மொழி Python (opens in a new tab) என்பதால், நாங்கள் அதை இங்கே பயன்படுத்துகிறோம். உங்களுக்கு Python தெரியாவிட்டால் கவலைப்பட வேண்டாம். மொழி மிகவும் தெளிவாக உள்ளது, அது என்ன செய்கிறது என்பதை நான் சரியாக விளக்குகிறேன்.

Web3 நூலகம் (opens in a new tab) என்பது மிகவும் பொதுவான Python எத்தேரியம் பயன்பாட்டு நிரலாக்க இடைமுகம் (API) ஆகும். இதைப் பயன்படுத்துவது மிகவும் எளிதானது.

பிளாக்செயினில் வர்த்தகம் செய்தல்

எத்தேரியத்தில் டோக்கன்களை வர்த்தகம் செய்ய உங்களை அனுமதிக்கும் பல பரவலாக்கப்பட்ட பரிமாற்றங்கள் (DEX) உள்ளன. இருப்பினும், ஆர்பிட்ரேஜ் காரணமாக அவை ஒரே மாதிரியான மாற்று விகிதங்களைக் கொண்டிருக்கின்றன.

Uniswap (opens in a new tab) என்பது பரவலாகப் பயன்படுத்தப்படும் ஒரு DEX ஆகும், அதை நாம் மேற்கோள்கள் (டோக்கன் சார்பு மதிப்புகளைப் பார்க்க) மற்றும் வர்த்தகங்கள் ஆகிய இரண்டிற்கும் பயன்படுத்தலாம்.

OpenAI

ஒரு பெரிய மொழி மாதிரிக்கு, நான் OpenAI (opens in a new tab)-உடன் தொடங்கத் தேர்ந்தெடுத்தேன். இந்த டுடோரியலில் உள்ள பயன்பாட்டை இயக்க நீங்கள் பயன்பாட்டு நிரலாக்க இடைமுக (API) அணுகலுக்கு பணம் செலுத்த வேண்டும். குறைந்தபட்ச கட்டணமான $5 போதுமானதை விட அதிகமாக உள்ளது.

படிப்படியான உருவாக்கம்

உருவாக்கத்தை எளிதாக்க, நாம் நிலைகளில் தொடர்கிறோம். ஒவ்வொரு படியும் GitHub-இல் ஒரு கிளை.

தொடங்குதல்

UNIX அல்லது Linux (WSL (opens in a new tab) உட்பட) கீழ் தொடங்குவதற்கான படிகள் உள்ளன

  1. உங்களிடம் ஏற்கனவே இல்லை என்றால், Python (opens in a new tab)-ஐ பதிவிறக்கம் செய்து நிறுவவும்.

  2. GitHub களஞ்சியத்தை நகலெடுக்கவும்.

    1git clone https://github.com/qbzzt/260215-ai-agent.git -b 01-getting-started
    2cd 260215-ai-agent

  3. uv (opens in a new tab)-ஐ நிறுவவும். உங்கள் கணினியில் உள்ள கட்டளை வித்தியாசமாக இருக்கலாம்.

    1pipx install uv

  4. நூலகங்களைப் பதிவிறக்கவும்.

    1uv sync

  5. மெய்நிகர் சூழலைச் செயல்படுத்தவும்.

    1source .venv/bin/activate

  6. Python மற்றும் Web3 சரியாக வேலை செய்கின்றனவா என்பதைச் சரிபார்க்க, python3-ஐ இயக்கி, இந்த நிரலை அதற்கு வழங்கவும். நீங்கள் அதை >>> ப்ராம்ட்டில் உள்ளிடலாம்; ஒரு கோப்பை உருவாக்க வேண்டிய அவசியமில்லை.

    1from web3 import Web3
    2MAINNET_URL = "https://eth.drpc.org"
    3w3 = Web3(Web3.HTTPProvider(MAINNET_URL))
    4w3.eth.block_number
    5quit()

பிளாக்செயினிலிருந்து படித்தல்

அடுத்த படி பிளாக்செயினிலிருந்து படிப்பதாகும். அதைச் செய்ய, நீங்கள் 02-read-quote கிளைக்கு மாற வேண்டும், பின்னர் நிரலை இயக்க uv-ஐப் பயன்படுத்தவும்.

1git checkout 02-read-quote
2uv run agent.py

நீங்கள் Quote பொருட்களின் பட்டியலைப் பெறுவீர்கள், ஒவ்வொன்றும் ஒரு நேரமுத்திரை, ஒரு விலை, மற்றும் சொத்து (தற்போது எப்போதும் WETH/USDC) ஆகியவற்றுடன்.

இதோ ஒரு வரிக்கு வரி விளக்கம்.

1from web3 import Web3
2from web3.contract import Contract
3from decimal import Decimal, ROUND_HALF_UP
4from dataclasses import dataclass
5from datetime import datetime, timezone
6from pprint import pprint
7import time
8import functools
9import sys
அனைத்தையும் காட்டு

நமக்குத் தேவையான நூலகங்களை இறக்குமதி செய்யவும். அவை பயன்படுத்தப்படும்போது கீழே விளக்கப்பட்டுள்ளன.

1print = functools.partial(print, flush=True)

Python-இன் print-ஐ, வெளியீட்டை உடனடியாக எப்போதும் ஃப்ளஷ் செய்யும் ஒரு பதிப்புடன் மாற்றுகிறது. இது நீண்ட நேரம் இயங்கும் ஒரு ஸ்கிரிப்டில் பயனுள்ளதாக இருக்கும், ஏனெனில் நாம் நிலை புதுப்பிப்புகள் அல்லது பிழைதிருத்த வெளியீட்டிற்காகக் காத்திருக்க விரும்பவில்லை.

1MAINNET_URL = "https://eth.drpc.org"

மெயின்நெட்டிற்குச் செல்ல ஒரு URL. நீங்கள் சேவையாக முனை என்பதிலிருந்து ஒன்றைப் பெறலாம் அல்லது Chainlist (opens in a new tab)-இல் விளம்பரப்படுத்தப்பட்டவற்றில் ஒன்றைப் பயன்படுத்தலாம்.

1BLOCK_TIME_SECONDS = 12
2MINUTE_BLOCKS = int(60 / BLOCK_TIME_SECONDS)
3HOUR_BLOCKS = MINUTE_BLOCKS * 60
4DAY_BLOCKS = HOUR_BLOCKS * 24

ஒரு எத்தேரியம் மெயின்நெட் பிளாக் பொதுவாக ஒவ்வொரு பன்னிரண்டு வினாடிகளுக்கும் நடக்கும், எனவே இவை ஒரு காலப்பகுதியில் நடக்கும் என்று நாம் எதிர்பார்க்கும் பிளாக்குகளின் எண்ணிக்கையாகும். இது ஒரு துல்லியமான எண்ணிக்கை அல்ல என்பதை நினைவில் கொள்ளவும். பிளாக் ப்ரோபோஸர் செயலிழந்தால், அந்த பிளாக் தவிர்க்கப்பட்டு, அடுத்த பிளாக்கிற்கான நேரம் 24 வினாடிகள் ஆகும். ஒரு நேரமுத்திரைக்கு சரியான பிளாக்கைப் பெற நாம் விரும்பினால், நாம் பைனரி தேடலை (opens in a new tab)ப் பயன்படுத்துவோம். இருப்பினும், இது எங்கள் நோக்கங்களுக்குப் போதுமான அளவு நெருக்கமாக உள்ளது. எதிர்காலத்தைக் கணிப்பது ஒரு துல்லியமான அறிவியல் அல்ல.

1CYCLE_BLOCKS = DAY_BLOCKS

சுழற்சியின் அளவு. நாம் ஒவ்வொரு சுழற்சிக்கும் ஒரு முறை மேற்கோள்களை மதிப்பாய்வு செய்து, அடுத்த சுழற்சியின் முடிவில் மதிப்பை மதிப்பிட முயற்சிக்கிறோம்.

1# நாம் படிக்கும் பூலின் முகவரி
2WETHUSDC_ADDRESS = Web3.to_checksum_address("0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640")

மேற்கோள் மதிப்புகள் Uniswap 3 USDC/WETH பூலிலிருந்து 0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640 (opens in a new tab) என்ற முகவரியில் எடுக்கப்படுகின்றன. இந்த முகவரி ஏற்கனவே செக்சம் வடிவத்தில் உள்ளது, ஆனால் குறியீட்டை மீண்டும் பயன்படுத்தக்கூடியதாக மாற்ற Web3.to_checksum_address (opens in a new tab)-ஐப் பயன்படுத்துவது நல்லது.

1POOL_ABI = [
2    { "name": "slot0", ... },
3    { "name": "token0", ... },
4    { "name": "token1", ... },
5]
6
7ERC20_ABI = [
8    { "name": "symbol", ... },
9    { "name": "decimals", ... }
10]
அனைத்தையும் காட்டு

நாம் தொடர்பு கொள்ள வேண்டிய இரண்டு ஒப்பந்தங்களுக்கான ABIs (opens in a new tab) இவை. குறியீட்டைச் சுருக்கமாக வைத்திருக்க, நாம் அழைக்க வேண்டிய செயல்பாடுகளை மட்டுமே சேர்க்கிறோம்.

1w3 = Web3(Web3.HTTPProvider(MAINNET_URL))

Web3 (opens in a new tab) நூலகத்தைத் தொடங்கி, ஒரு எத்தேரியம் முனையுடன் இணைக்கவும்.

1@dataclass(frozen=True)
2class ERC20Token:
3    address: str
4    symbol: str
5    decimals: int
6    contract: Contract

இது Python-இல் ஒரு டேட்டா கிளாஸை உருவாக்குவதற்கான ஒரு வழி. Contract (opens in a new tab) தரவு வகை ஒப்பந்தத்துடன் இணைக்கப் பயன்படுகிறது. (frozen=True)-ஐக் கவனிக்கவும். Python-இல் பூலியன்கள் (opens in a new tab) True அல்லது False என்று பெரிய எழுத்தில் வரையறுக்கப்பட்டுள்ளன. இந்த டேட்டா கிளாஸ் frozen ஆகும், அதாவது புலங்களை மாற்ற முடியாது.

உள்தள்ளலைக் கவனிக்கவும். சி-பெறப்பட்ட மொழிகளுக்கு (opens in a new tab) மாறாக, Python பிளாக்குகளைக் குறிக்க உள்தள்ளலைப் பயன்படுத்துகிறது. பின்வரும் வரையறை இந்த டேட்டா கிளாஸின் ஒரு பகுதியாக இல்லை என்பதை Python இண்டர்பிரெட்டருக்குத் தெரியும், ஏனெனில் அது டேட்டா கிளாஸ் புலங்களின் அதே உள்தள்ளலில் தொடங்கவில்லை.

1@dataclass(frozen=True)
2class PoolInfo:
3    address: str
4    token0: ERC20Token
5    token1: ERC20Token
6    contract: Contract
7    asset: str
8    decimal_factor: Decimal = 1

தசம பின்னங்களைத் துல்லியமாகக் கையாள Decimal (opens in a new tab) வகை பயன்படுத்தப்படுகிறது.

1    def get_price(self, block: int) -> Decimal:

இது Python-இல் ஒரு செயல்பாட்டை வரையறுக்கும் வழி. வரையறை, அது இன்னும் PoolInfo-இன் ஒரு பகுதி என்பதைக் காட்ட உள்தள்ளப்பட்டுள்ளது.

ஒரு டேட்டா கிளாஸின் பகுதியாக இருக்கும் ஒரு செயல்பாட்டில் முதல் அளவுரு எப்போதும் self ஆகும், இது இங்கு அழைத்த டேட்டா கிளாஸ் நிகழ்வு. இங்கே மற்றொரு அளவுரு, பிளாக் எண் உள்ளது.

1        assert block <= w3.eth.block_number, "பிளாக் எதிர்காலத்தில் உள்ளது"

நாம் எதிர்காலத்தைப் படிக்க முடிந்தால், வர்த்தகத்திற்கு நமக்கு AI தேவையில்லை.

1        sqrt_price_x96 = Decimal(self.contract.functions.slot0().call(block_identifier=block)[0])

Web3-இலிருந்து EVM-இல் ஒரு செயல்பாட்டை அழைப்பதற்கான தொடரியல் இதுவாகும்: <contract object>.functions.<function name>"().call(<parameters>). அளவுருக்கள் EVM செயல்பாட்டின் அளவுருக்களாக (ஏதேனும் இருந்தால்; இங்கே இல்லை) அல்லது பிளாக்செயின் நடத்தையை மாற்றுவதற்கான பெயரிடப்பட்ட அளவுருக்களாக (opens in a new tab) இருக்கலாம். நாம் இயக்க விரும்பும் பிளாக் எண்ணைக் குறிப்பிட, இங்கே நாம் block_identifier ஐப் பயன்படுத்துகிறோம்.

இதன் விளைவு இந்த struct, அணி வடிவத்தில் (opens in a new tab) ஆகும். முதல் மதிப்பு என்பது இரண்டு டோக்கன்களுக்கு இடையிலான மாற்று விகிதத்தின் ஒரு செயல்பாடாகும்.

1        raw_price = (sqrt_price_x96 / Decimal(2**96)) ** 2

ஆன்செயின் கணக்கீடுகளைக் குறைக்க, Uniswap v3 உண்மையான மாற்று காரணியைச் சேமிக்காமல் அதன் வர்க்க மூலத்தைச் சேமிக்கிறது. EVM மிதவைப் புள்ளி கணிதம் அல்லது பின்னங்களை ஆதரிக்காததால், உண்மையான மதிப்புக்கு பதிலாக, பதில் price&#x22C5296 ஆகும்.

1         # (டோக்கன்1 க்கு டோக்கன்0)
2        return 1/(raw_price * self.decimal_factor)

நாம் பெறும் மூல விலை என்பது ஒவ்வொரு token1-க்கும் நாம் பெறும் token0-இன் எண்ணிக்கையாகும். நமது பூலில் token0 என்பது USDC (அமெரிக்க டாலரின் அதே மதிப்பைக் கொண்ட ஒரு ஸ்டேபிள்காயின்) மற்றும் token1 என்பது WETH (opens in a new tab) ஆகும். நாம் உண்மையில் விரும்பும் மதிப்பு ஒரு WETH-க்கான டாலர்களின் எண்ணிக்கை, அதன் நேர்மாறு அல்ல.

தசம காரணி என்பது இரண்டு டோக்கன்களுக்கான தசம காரணிகளுக்கு (opens in a new tab) இடையிலான விகிதமாகும்.

1@dataclass(frozen=True)
2class Quote:
3    timestamp: str
4    price: Decimal
5    asset: str

இந்த டேட்டா கிளாஸ் ஒரு மேற்கோளைக் குறிக்கிறது: ஒரு குறிப்பிட்ட நேரத்தில் ஒரு குறிப்பிட்ட சொத்தின் விலை. இந்த நேரத்தில், asset புலம் பொருத்தமற்றது, ஏனெனில் நாம் ஒரே ஒரு பூலைப் பயன்படுத்துகிறோம், எனவே ஒரே ஒரு சொத்து உள்ளது. இருப்பினும், நாம் பின்னர் மேலும் சொத்துக்களைச் சேர்ப்போம்.

1def read_token(address: str) -> ERC20Token:
2    token = w3.eth.contract(address=address, abi=ERC20_ABI)
3    symbol = token.functions.symbol().call()
4    decimals = token.functions.decimals().call()
5
6    return ERC20Token(
7        address=address,
8        symbol=symbol,
9        decimals=decimals,
10        contract=token
11    )
அனைத்தையும் காட்டு

இந்தச் செயல்பாடு ஒரு முகவரியை எடுத்து, அந்த முகவரியில் உள்ள டோக்கன் ஒப்பந்தம் பற்றிய தகவலைத் தருகிறது. ஒரு புதிய Web3 Contract (opens in a new tab) ஐ உருவாக்க, நாம் முகவரி மற்றும் பயன்பாடு பைனரி இடைமுகம் (ABI)-ஐ w3.eth.contract-க்கு வழங்குகிறோம்.

1def read_pool(address: str) -> PoolInfo:
2    pool_contract = w3.eth.contract(address=address, abi=POOL_ABI)
3    token0Address = pool_contract.functions.token0().call()
4    token1Address = pool_contract.functions.token1().call()
5    token0 = read_token(token0Address)
6    token1 = read_token(token1Address)
7
8    return PoolInfo(
9        address=address,
10        asset=f"{token1.symbol}/{token0.symbol}",
11        token0=token0,
12        token1=token1,
13        contract=pool_contract,
14        decimal_factor=Decimal(10) ** Decimal(token0.decimals - token1.decimals)
15    )
அனைத்தையும் காட்டு

இந்தச் செயல்பாடு ஒரு குறிப்பிட்ட பூல் (opens in a new tab) பற்றி நமக்குத் தேவையான அனைத்தையும் தருகிறது. f"<string>" தொடரியல் ஒரு வடிவமைக்கப்பட்ட சரம் (opens in a new tab) ஆகும்.

1def get_quote(pool: PoolInfo, block_number: int = None) -> Quote:

ஒரு Quote பொருளைப் பெறவும். block_number-க்கான இயல்புநிலை மதிப்பு None (மதிப்பு இல்லை) ஆகும்.

1    if block_number is None:
2        block_number = w3.eth.block_number

ஒரு பிளாக் எண் குறிப்பிடப்படவில்லை என்றால், w3.eth.block_number-ஐப் பயன்படுத்தவும், இது சமீபத்திய பிளாக் எண் ஆகும். இது ஒரு if கூற்றிற்கான (opens in a new tab) தொடரியல் ஆகும்.

இயல்புநிலையை w3.eth.block_number என அமைப்பது சிறப்பாக இருந்திருக்கும் என்று தோன்றலாம், ஆனால் அது நன்றாக வேலை செய்யாது, ஏனெனில் அது செயல்பாடு வரையறுக்கப்படும் நேரத்தில் பிளாக் எண்ணாக இருக்கும். நீண்டகாலமாக இயங்கும் ஒரு முகவரில் இது ஒரு பிரச்சனையாக இருக்கும்.

1    block = w3.eth.get_block(block_number)
2    price = pool.get_price(block_number)
3    return Quote(
4        timestamp=datetime.fromtimestamp(block.timestamp, timezone.utc).isoformat(),
5        price=price.quantize(Decimal("0.01")),
6        asset=pool.asset
7    )

மனிதர்கள் மற்றும் பெரிய மொழி மாதிரிகள் (LLMs) படிக்கக்கூடிய வடிவத்திற்கு அதை வடிவமைக்க the datetime library (opens in a new tab) ஐப் பயன்படுத்தவும். மதிப்பை இரண்டு தசம இடங்களுக்கு округляಲು Decimal.quantize (opens in a new tab) ஐப் பயன்படுத்தவும்.

1def get_quotes(pool: PoolInfo, start_block: int, end_block: int, step: int) -> list[Quote]:

Python இல் நீங்கள் list[<type>] ஐப் பயன்படுத்தி ஒரு குறிப்பிட்ட வகையை மட்டுமே கொண்டிருக்கக்கூடிய ஒரு பட்டியலை (opens in a new tab) வரையறுக்கிறீர்கள்.

1    quotes = []
2    for block in range(start_block, end_block + 1, step):

Python இல் ஒரு for loop (opens in a new tab) பொதுவாக ஒரு பட்டியலை மீண்டும் செய்கிறது. மேற்கோள்களைக் கண்டறிய வேண்டிய பிளாக் எண்களின் பட்டியல் range (opens in a new tab)-இலிருந்து வருகிறது.

1        quote = get_quote(pool, block)
2        quotes.append(quote)
3    return quotes

ஒவ்வொரு பிளாக் எண்ணுக்கும், ஒரு Quote பொருளைப் பெற்று அதை quotes பட்டியலில் சேர்க்கவும். பிறகு அந்தப் பட்டியலைத் திருப்பி அனுப்பவும்.

1pool = read_pool(WETHUSDC_ADDRESS)
2quotes = get_quotes(
3    pool,
4    w3.eth.block_number - 12*CYCLE_BLOCKS,
5    w3.eth.block_number,
6    CYCLE_BLOCKS
7)
8
9pprint(quotes)
அனைத்தையும் காட்டு

இது ஸ்கிரிப்டின் முக்கிய குறியீடு. பூல் தகவலைப் படித்து, பன்னிரண்டு மேற்கோள்களைப் பெற்று, அவற்றை pprint (opens in a new tab) செய்யவும்.

ஒரு ப்ராம்ப்டை உருவாக்குதல்

அடுத்து, இந்த மேற்கோள்களின் பட்டியலை ஒரு LLM-க்கான ப்ராம்ப்டாக மாற்றி, எதிர்பார்க்கப்படும் எதிர்கால மதிப்பைப் பெற வேண்டும்.

1git checkout 03-create-prompt
2uv run agent.py

வெளியீடு இப்போது ஒரு LLM-க்கான ப்ராம்ப்டாக இருக்கும், இது போன்றது:

1இந்தப் மேற்கோள்களைக் கருத்தில் கொள்ளுங்கள்:
2சொத்து: WETH/USDC
3        2026-01-20T16:34 3016.21
4        .
5        .
6        .
7        2026-02-01T17:49 2299.10
8
9சொத்து: WBTC/WETH
10        2026-01-20T16:34 29.84
11        .
12        .
13        .
14        2026-02-01T17:50 33.46
15
16
172026-02-02T17:56 நேரத்தில் WETH/USDC-க்கான மதிப்பு என்னவாக இருக்கும் என்று நீங்கள் எதிர்பார்க்கிறீர்கள்?
18
19உங்கள் பதிலை இரண்டு தசம இடங்களுக்குச் சுருக்கி ஒரு ஒற்றை எண்ணாக வழங்கவும்,
20வேறு எந்த உரையும் இல்லாமல்.
அனைத்தையும் காட்டு

இங்கே WETH/USDC மற்றும் WBTC/WETH ஆகிய இரண்டு சொத்துக்களுக்கான மேற்கோள்கள் இருப்பதை கவனியுங்கள். மற்றொரு சொத்திலிருந்து மேற்கோள்களைச் சேர்ப்பது கணிப்புத் துல்லியத்தை மேம்படுத்தக்கூடும்.

ஒரு ப்ராம்ட் எப்படி இருக்கும்

இந்த ப்ராம்ட் மூன்று பிரிவுகளைக் கொண்டுள்ளது, அவை LLM ப்ராம்ட்களில் மிகவும் பொதுவானவை.

  1. தகவல். LLMகள் தங்கள் பயிற்சியிலிருந்து நிறைய தகவல்களைக் கொண்டுள்ளன, ஆனால் அவை பொதுவாக சமீபத்திய தகவல்களைக் கொண்டிருக்காது. இதனால்தான் நாம் இங்கே சமீபத்திய மேற்கோள்களைப் பெற வேண்டும். ஒரு ப்ராம்ட்டில் தகவல்களைச் சேர்ப்பது மீட்பு மேம்படுத்தப்பட்ட உருவாக்கம் (RAG) (opens in a new tab) என்று அழைக்கப்படுகிறது.

  2. உண்மையான கேள்வி. இதைத்தான் நாம் தெரிந்து கொள்ள விரும்புகிறோம்.

  3. வெளியீட்டு வடிவமைப்பு வழிமுறைகள். பொதுவாக, ஒரு LLM அது எப்படி மதிப்பிட்டது என்ற விளக்கத்துடன் ஒரு மதிப்பீட்டை நமக்கு வழங்கும். இது மனிதர்களுக்கு நல்லது, ஆனால் ஒரு கணினி நிரலுக்கு முடிவு மட்டுமே தேவை.

குறியீடு விளக்கம்

இதோ புதிய குறியீடு.

1from datetime import datetime, timezone, timedelta

நாம் ஒரு மதிப்பீட்டை விரும்பும் நேரத்தை LLM-க்கு வழங்க வேண்டும். எதிர்காலத்தில் "n நிமிடங்கள்/மணிநேரங்கள்/நாட்கள்" என்ற நேரத்தைப் பெற, நாம் the timedelta class (opens in a new tab)-ஐப் பயன்படுத்துகிறோம்.

1# நாம் படிக்கும் பூல்களின் முகவரிகள்
2WETHUSDC_ADDRESS = Web3.to_checksum_address("0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640")
3WETHWBTC_ADDRESS = Web3.to_checksum_address("0xCBCdF9626bC03E24f779434178A73a0B4bad62eD")

நாம் படிக்க வேண்டிய இரண்டு பூல்கள் உள்ளன.

1@dataclass(frozen=True)
2class PoolInfo:
3    .
4    .
5    .
6    reverse: bool = False
7
8    def get_price(self, block: int) -> Decimal:
9        assert block <= w3.eth.block_number, "பிளாக் எதிர்காலத்தில் உள்ளது"
10        sqrt_price_x96 = Decimal(self.contract.functions.slot0().call(block_identifier=block)[0])
11        raw_price = (sqrt_price_x96 / Decimal(2**96)) ** 2  # (டோக்கன்1 க்கு டோக்கன்0)
12        if self.reverse:
13            return 1/(raw_price * self.decimal_factor)
14        else:
15            return raw_price * self.decimal_factor
அனைத்தையும் காட்டு

WETH/USDC பூலில், token0 (USDC) இல் இருந்து ஒரு token1 (WETH)-ஐ வாங்க எவ்வளவு தேவை என்பதை அறிய விரும்புகிறோம். WETH/WBTC பூலில், token0 (WBTC, இது வ்ராப்ட் பிட்காயின்) ஐ வாங்க எவ்வளவு token1 (WETH) தேவை என்பதை நாம் அறிய விரும்புகிறோம். பூலின் விகிதம் மாற்றப்பட வேண்டுமா என்பதைக் கண்காணிக்க வேண்டும்.

1def read_pool(address: str, reverse: bool = False) -> PoolInfo:
2    .
3    .
4    .
5
6    return PoolInfo(
7        .
8        .
9        .
10
11        asset= f"{token1.symbol}/{token0.symbol}" if reverse else f"{token0.symbol}/{token1.symbol}",
12        reverse=reverse
13    )
அனைத்தையும் காட்டு

ஒரு பூல் மாற்றப்பட வேண்டுமா என்பதை அறிய, அதை read_pool-க்கு உள்ளீடாகப் பெறுகிறோம். மேலும், சொத்தின் சின்னம் சரியாக அமைக்கப்பட வேண்டும்.

<a> if <b> else <c> தொடரியல் Python-இன் மும்மை நிபந்தனை ஆபரேட்டருக்கு (opens in a new tab) சமமானது, இது C-பெறப்பட்ட மொழியில் <b> ? <a> : <c> ஆக இருக்கும்.

1def format_quotes(quotes: list[Quote]) -> str:
2    result = f"சொத்து: {quotes[0].asset}\n"
3    for quote in quotes:
4        result += f"\t{quote.timestamp[0:16]} {quote.price.quantize(Decimal('0.01'), rounding=ROUND_HALF_UP)}\n"
5    return result

இந்தச் செயல்பாடு, Quote பொருட்களின் பட்டியலை வடிவமைக்கும் ஒரு சரத்தை உருவாக்குகிறது, அவை அனைத்தும் ஒரே சொத்துக்குப் பொருந்தும் என்று கருதி.

1def make_prompt(quotes: list[list[Quote]], expected_time: str, asset: str) -> str:
2    return f"""

Python-இல் பல-வரி சரங்கள் (opens in a new tab) """ .... என எழுதப்படுகின்றன. """.

1இந்த மேற்கோள்களைக் கருத்தில் கொள்ளுங்கள்:
2{
3    functools.reduce(lambda acc, q: acc + '\n' + q,
4        map(lambda q: format_quotes(q), quotes))
5}

இங்கே, ஒவ்வொரு மேற்கோள் பட்டியலுக்கும் format_quotes-உடன் ஒரு சரத்தை உருவாக்க MapReduce (opens in a new tab) முறையைப் பயன்படுத்துகிறோம், பின்னர் அவற்றை ப்ராம்ட்டில் பயன்படுத்த ஒரு ஒற்றை சரமாக குறைக்கிறோம்.

1{asset}-க்கான மதிப்பு {expected_time} நேரத்தில் என்னவாக இருக்கும் என்று எதிர்பார்க்கிறீர்கள்?
2
3உங்கள் பதிலை இரண்டு தசம இடங்களுக்குச் சுருக்கி ஒரு ஒற்றை எண்ணாக வழங்கவும்,
4வேறு எந்த உரையும் இல்லாமல்.
5    """

ப்ராம்ட்டின் மீதமுள்ள பகுதி எதிர்பார்த்தபடியே உள்ளது.

1wethusdc_pool = read_pool(WETHUSDC_ADDRESS, True)
2wethusdc_quotes = get_quotes(
3    wethusdc_pool,
4    w3.eth.block_number - 12*CYCLE_BLOCKS,
5    w3.eth.block_number,
6    CYCLE_BLOCKS,
7)
8
9wethwbtc_pool = read_pool(WETHWBTC_ADDRESS)
10wethwbtc_quotes = get_quotes(
11    wethwbtc_pool,
12    w3.eth.block_number - 12*CYCLE_BLOCKS,
13    w3.eth.block_number,
14    CYCLE_BLOCKS
15)
அனைத்தையும் காட்டு

இரண்டு பூல்களையும் மதிப்பாய்வு செய்து, இரண்டிலிருந்தும் மேற்கோள்களைப் பெறவும்.

1future_time = (datetime.now(timezone.utc) + timedelta(days=1)).isoformat()[0:16]
2
3print(make_prompt(wethusdc_quotes + wethwbtc_quotes, future_time, wethusdc_pool.asset))

நாம் மதிப்பீட்டை விரும்பும் எதிர்கால நேரப் புள்ளியைத் தீர்மானித்து, ப்ராம்ப்டை உருவாக்கவும்.

ஒரு LLM உடன் இடைமுகம் செய்தல்

அடுத்து, நாம் ஒரு உண்மையான LLM-ஐ ப்ராம்ட் செய்து, எதிர்பார்க்கப்படும் எதிர்கால மதிப்பைப் பெறுகிறோம். நான் இந்த நிரலை OpenAI-ஐப் பயன்படுத்தி எழுதினேன், எனவே நீங்கள் வேறு ஒரு வழங்குநரைப் பயன்படுத்த விரும்பினால், நீங்கள் அதை சரிசெய்ய வேண்டும்.

  1. ஒரு OpenAI கணக்கை (opens in a new tab)ப் பெறவும்

  2. கணக்கிற்கு நிதியளிக்கவும் (opens in a new tab)—எழுதுகின்ற நேரத்தில் குறைந்தபட்சத் தொகை $5 ஆகும்

  3. ஒரு பயன்பாட்டு நிரலாக்க இடைமுகம் (API) விசையை உருவாக்கவும் (opens in a new tab)

  4. கட்டளை வரியில், உங்கள் நிரல் அதைப் பயன்படுத்தும் வகையில் பயன்பாட்டு நிரலாக்க இடைமுகம் (API) விசையை ஏற்றுமதி செய்யவும்

    1export OPENAI_API_KEY=sk-<விசையின் மீதமுள்ள பகுதி இங்கே வரும்>

  5. முகவரை சரிபார்த்து இயக்கவும்

    1git checkout 04-interface-llm
    2uv run agent.py

இதோ புதிய குறியீடு.

1from openai import OpenAI
2
3open_ai = OpenAI() # வாடிக்கையாளர் OPENAI_API_KEY சூழல் மாறியைப் படிக்கிறார்

OpenAI பயன்பாட்டு நிரலாக்க இடைமுகம் (API)-ஐ இறக்குமதி செய்து செயல்படுத்தவும்.

1response = open_ai.chat.completions.create(
2    model="gpt-4-turbo",
3    messages=[
4        {"role": "பயனர்", "content": prompt}
5    ],
6    temperature=0.0,
7    max_tokens=16,
8)

பதிலை உருவாக்க OpenAI பயன்பாட்டு நிரலாக்க இடைமுகம் (API)-ஐ (open_ai.chat.completions.create) அழைக்கவும்.

1expected_price = Decimal(response.choices[0].message.content.strip())
2current_price = wethusdc_quotes[-1].price
3
4print ("தற்போதைய விலை:", wethusdc_quotes[-1].price)
5print(f"{future_time}-இல், எதிர்பார்க்கப்படும் விலை: {expected_price} USD")
6
7if (expected_price > current_price):
8    print(f"வாங்கு, விலை {expected_price - current_price} USD உயரும் என்று எதிர்பார்க்கிறேன்")
9else:
10    print(f"விற்பனை செய், விலை {current_price - expected_price} USD குறையும் என்று எதிர்பார்க்கிறேன்")
அனைத்தையும் காட்டு

விலையை வெளியிட்டு, வாங்க அல்லது விற்க பரிந்துரையை வழங்கவும்.

கணிப்புகளைச் சோதித்தல்

இப்போது நாம் கணிப்புகளை உருவாக்க முடியும் என்பதால், நாம் பயனுள்ள கணிப்புகளை உருவாக்குகிறோமா என்பதை மதிப்பிடுவதற்கு வரலாற்றுத் தரவையும் பயன்படுத்தலாம்.

1uv run test-predictor.py

எதிர்பார்க்கப்படும் முடிவு இது போன்றது:

12026-01-05T19:50-க்கான கணிப்பு: கணிக்கப்பட்டது 3138.93 USD, உண்மையானது 3218.92 USD, பிழை 79.99 USD
22026-01-06T19:56-க்கான கணிப்பு: கணிக்கப்பட்டது 3243.39 USD, உண்மையானது 3221.08 USD, பிழை 22.31 USD
32026-01-07T20:02-க்கான கணிப்பு: கணிக்கப்பட்டது 3223.24 USD, உண்மையானது 3146.89 USD, பிழை 76.35 USD
42026-01-08T20:11-க்கான கணிப்பு: கணிக்கப்பட்டது 3150.47 USD, உண்மையானது 3092.04 USD, பிழை 58.43 USD
5.
6.
7.
82026-01-31T22:33-க்கான கணிப்பு: கணிக்கப்பட்டது 2637.73 USD, உண்மையானது 2417.77 USD, பிழை 219.96 USD
92026-02-01T22:41-க்கான கணிப்பு: கணிக்கப்பட்டது 2381.70 USD, உண்மையானது 2318.84 USD, பிழை 62.86 USD
102026-02-02T22:49-க்கான கணிப்பு: கணிக்கப்பட்டது 2234.91 USD, உண்மையானது 2349.28 USD, பிழை 114.37 USD
1129 கணிப்புகளின் சராசரி கணிப்பு பிழை: 83.87103448275862068965517241 USD
12ஒரு பரிந்துரைக்கான சராசரி மாற்றம்: 4.787931034482758620689655172 USD
13மாற்றங்களின் நிலையான மாறுபாடு: 104.42 USD
14இலாபகரமான நாட்கள்: 51.72%
15இழப்பு நாட்கள்: 48.28%
அனைத்தையும் காட்டு

சோதனையாளரின் பெரும்பகுதி முகவரைப் போலவே உள்ளது, ஆனால் புதிய அல்லது மாற்றியமைக்கப்பட்ட பகுதிகள் இங்கே உள்ளன.

1CYCLES_FOR_TEST = 40 # பேக்டெஸ்டுக்கு, நாம் எத்தனை சுழற்சிகளைச் சோதிக்கிறோம்
2
3# நிறைய மேற்கோள்களைப் பெறவும்
4wethusdc_pool = read_pool(WETHUSDC_ADDRESS, True)
5wethusdc_quotes = get_quotes(
6    wethusdc_pool,
7    w3.eth.block_number - CYCLE_BLOCKS*CYCLES_FOR_TEST,
8    w3.eth.block_number,
9    CYCLE_BLOCKS,
10)
11
12wethwbtc_pool = read_pool(WETHWBTC_ADDRESS)
13wethwbtc_quotes = get_quotes(
14    wethwbtc_pool,
15    w3.eth.block_number - CYCLE_BLOCKS*CYCLES_FOR_TEST,
16    w3.eth.block_number,
17    CYCLE_BLOCKS
18)
அனைத்தையும் காட்டு

நாம் CYCLES_FOR_TEST (இங்கே 40 என குறிப்பிடப்பட்டுள்ளது) நாட்களை பின்னோக்கிப் பார்க்கிறோம்.

1# கணிப்புகளை உருவாக்கி அவற்றை உண்மையான வரலாற்றுடன் சரிபார்க்கவும்
2
3total_error = Decimal(0)
4changes = []

நாம் ஆர்வமாக உள்ள இரண்டு வகையான பிழைகள் உள்ளன. முதலாவது, total_error, கணிப்பாளர் செய்த பிழைகளின் மொத்தமாகும்.

இரண்டாவதாக, changes-ஐப் புரிந்து கொள்ள, முகவரின் நோக்கத்தை நாம் நினைவில் கொள்ள வேண்டும். WETH/USDC விகிதத்தை (ETH விலை) கணிப்பது அல்ல. விற்பனை மற்றும் வாங்குதல் பரிந்துரைகளை வழங்குவதே அதன் நோக்கம். விலை தற்போது $2000 ஆக இருந்து, நாளை $2010 ஆக இருக்கும் என்று கணித்தால், உண்மையான முடிவு $2020 ஆக இருந்தால், நாம் கூடுதல் பணம் சம்பாதிப்பதால் கவலைப்பட மாட்டோம். ஆனால், அது $2010 என்று கணித்து, அந்தப் பரிந்துரையின் அடிப்படையில் ETH ஐ வாங்கி, விலை $1990 ஆகக் குறைந்தால் நாம் கவலைப்படுவோம்.

1for index in range(0,len(wethusdc_quotes)-CYCLES_BACK):

முழுமையான வரலாறு (கணிப்பிற்காகப் பயன்படுத்தப்பட்ட மதிப்புகள் மற்றும் அதை ஒப்பிடுவதற்கான உண்மையான மதிப்பு) கிடைக்கும் நிகழ்வுகளை மட்டுமே நாம் பார்க்க முடியும். இதன் பொருள் புதிய வழக்கு CYCLES_BACK முன்பு தொடங்கியதாக இருக்க வேண்டும்.

1    wethusdc_slice = wethusdc_quotes[index:index+CYCLES_BACK]
2    wethwbtc_slice = wethwbtc_quotes[index:index+CYCLES_BACK]

முகவர் பயன்படுத்தும் மாதிரிகளின் அதே எண்ணிக்கையைப் பெற ஸ்லைஸ்களை (opens in a new tab)ப் பயன்படுத்தவும். இங்குள்ள மற்றும் அடுத்த பிரிவிற்கு இடையிலான குறியீடு, முகவரில் நாம் வைத்திருக்கும் அதே கணிப்பு-பெறும் குறியீடு ஆகும்.

1    predicted_price = Decimal(response.choices[0].message.content.strip())
2    real_price = wethusdc_quotes[index+CYCLES_BACK].price
3    prediction_time_price = wethusdc_quotes[index+CYCLES_BACK-1].price

கணிக்கப்பட்ட விலை, உண்மையான விலை மற்றும் கணிப்பு நேரத்தில் இருந்த விலை ஆகியவற்றைப் பெறவும். பரிந்துரை வாங்குவதா அல்லது விற்பதா என்பதைத் தீர்மானிக்க கணிப்பு நேரத்தில் இருந்த விலை நமக்குத் தேவை.

1    error = abs(predicted_price - real_price)
2    total_error += error
3    print (f"{prediction_time}-க்கான கணிப்பு: கணிக்கப்பட்டது {predicted_price} USD, உண்மையானது {real_price} USD, பிழை {error} USD")

பிழையைக் கண்டுபிடித்து, அதை மொத்தத்துடன் சேர்க்கவும்.

1    recomended_action = 'வாங்க' என்றால் predicted_price > prediction_time_price else 'விற்பனை'
2    price_increase = real_price - prediction_time_price
3    changes.append(price_increase if recomended_action == 'வாங்க' else -price_increase)

changes-க்கு, ஒரு ETH-ஐ வாங்குவதன் அல்லது விற்பதன் பணத் தாக்கத்தை நாம் விரும்புகிறோம். எனவே முதலில், நாம் பரிந்துரையைத் தீர்மானிக்க வேண்டும், பின்னர் உண்மையான விலை எவ்வாறு மாறியது என்பதை மதிப்பீடு செய்ய வேண்டும், மற்றும் பரிந்துரை பணம் சம்பாதித்ததா (நேர்மறை மாற்றம்) அல்லது பணத்தை இழந்ததா (எதிர்மறை மாற்றம்) என்பதை மதிப்பிட வேண்டும்.

1print (f"{len(wethusdc_quotes)-CYCLES_BACK} கணிப்புகளுக்கான சராசரி கணிப்பு பிழை: {total_error / Decimal(len(wethusdc_quotes)-CYCLES_BACK)} USD")
2
3length_changes = Decimal(len(changes))
4mean_change = sum(changes, Decimal(0)) / length_changes
5print (f"ஒரு பரிந்துரைக்கான சராசரி மாற்றம்: {mean_change} USD")
6var = sum((x - mean_change) ** 2 for x in changes) / length_changes
7print (f"மாற்றங்களின் நிலையான மாறுபாடு: {var.sqrt().quantize(Decimal("0.01"))} USD")

முடிவுகளைப் புகாரளிக்கவும்.

1print (f"இலாபகரமான நாட்கள்: {len(list(filter(lambda x: x > 0, changes)))/length_changes:.2%}")
2print (f"இழப்பு நாட்கள்: {len(list(filter(lambda x: x < 0, changes)))/length_changes:.2%}")

இலாபகரமான நாட்கள் மற்றும் செலவுமிக்க நாட்களின் எண்ணிக்கையைக் கணக்கிட filter (opens in a new tab) ஐப் பயன்படுத்தவும். முடிவு ஒரு ஃபில்டர் பொருள், நீளத்தைப் பெற அதை ஒரு பட்டியலாக மாற்ற வேண்டும்.

பரிவர்த்தனைகளைச் சமர்ப்பித்தல்

இப்போது நாம் உண்மையில் பரிவர்த்தனைகளைச் சமர்ப்பிக்க வேண்டும். இருப்பினும், அமைப்பு நிரூபிக்கப்படுவதற்கு முன்பு, இந்த நேரத்தில் நான் உண்மையான பணத்தைச் செலவழிக்க விரும்பவில்லை. அதற்கு பதிலாக, மெயின்நெட்டின் ஒரு உள்ளூர் ஃபோர்க்கை உருவாக்கி, அந்த நெட்வொர்க்கில் "வர்த்தகம்" செய்வோம்.

ஒரு உள்ளூர் ஃபோர்க்கை உருவாக்கி, வர்த்தகத்தை இயக்குவதற்கான படிகள் இங்கே.

  1. Foundry (opens in a new tab)-ஐ நிறுவவும்

  2. anvil (opens in a new tab)-ஐத் தொடங்கவும்

    1anvil --fork-url https://eth.drpc.org --block-time 12

    anvil Foundry-க்கான இயல்புநிலை URL, http://localhost:8545-இல் (opens in a new tab) கேட்கிறது, எனவே நாம் பிளாக்செயினைக் கையாளப் பயன்படுத்தும் the cast command (opens in a new tab)-க்கான URL-ஐக் குறிப்பிடத் தேவையில்லை.

  3. anvil-இல் இயக்கும்போது, ETH உள்ள பத்து சோதனை கணக்குகள் உள்ளன—முதலாவதுக்கான சூழல் மாறிகளை அமைக்கவும்

    1PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80
    2ADDRESS=`cast wallet address $PRIVATE_KEY`

  4. நாம் பயன்படுத்த வேண்டிய ஒப்பந்தங்கள் இவை. SwapRouter (opens in a new tab) என்பது நாம் உண்மையில் வர்த்தகம் செய்யப் பயன்படுத்தும் Uniswap v3 ஒப்பந்தமாகும். நாம் நேரடியாக பூல் வழியாக வர்த்தகம் செய்யலாம், ஆனால் இது மிகவும் எளிதானது.

    கீழே உள்ள இரண்டு மாறிகளும் WETH மற்றும் USDC இடையே மாற்றத் தேவையான Uniswap v3 பாதைகள் ஆகும்.

    1WETH_ADDRESS=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
    2USDC_ADDRESS=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
    3POOL_ADDRESS=0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640
    4SWAP_ROUTER=0xE592427A0AEce92De3Edee1F18E0157C05861564
    5WETH_TO_USDC=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc20001F4A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48
    6USDC_TO_WETH=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB480001F4C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2

  5. ஒவ்வொரு சோதனை கணக்கிலும் 10,000 ETH உள்ளது. வர்த்தகத்திற்காக 1000 WETH பெற 1000 ETH-ஐ வ்ராப் செய்ய WETH ஒப்பந்தத்தைப் பயன்படுத்தவும்.

    1cast send $WETH_ADDRESS "deposit()" --value 1000ether --private-key $PRIVATE_KEY

  6. 500 WETH-ஐ USDC-க்கு வர்த்தகம் செய்ய SwapRouter-ஐப் பயன்படுத்தவும்.

    1cast send $WETH_ADDRESS "approve(address,uint256)" $SWAP_ROUTER 500ether --private-key $PRIVATE_KEY
    2MAXINT=`cast max-int uint256`
    3cast send $SWAP_ROUTER \
    4    "exactInput((bytes,address,uint256,uint256,uint256))" \
    5    "($WETH_TO_USDC,$ADDRESS,$MAXINT,500ether,1000000)" \
    6    --private-key $PRIVATE_KEY

    approve அழைப்பு, SwapRouter எங்கள் டோக்கன்களில் சிலவற்றை செலவழிக்க அனுமதிக்கும் ஒரு அனுமதியை உருவாக்குகிறது. ஒப்பந்தங்கள் நிகழ்வுகளைக் கண்காணிக்க முடியாது, எனவே நாம் நேரடியாக SwapRouter ஒப்பந்தத்திற்கு டோக்கன்களை மாற்றினால், அது பணம் செலுத்தப்பட்டதை அறியாது. அதற்கு பதிலாக, SwapRouter ஒப்பந்தத்தை ஒரு குறிப்பிட்ட தொகையைச் செலவழிக்க அனுமதிக்கிறோம், பின்னர் SwapRouter அதைச் செய்கிறது. இது SwapRouter ஆல் அழைக்கப்படும் ஒரு செயல்பாடு மூலம் செய்யப்படுகிறது, எனவே அது வெற்றிகரமாக இருந்ததா என்பதை அறியும்.

  7. உங்களிடம் இரண்டு டோக்கன்களும் போதுமான அளவு உள்ளதா என்பதைச் சரிபார்க்கவும்.

    1cast call $WETH_ADDRESS "balanceOf(address)" $ADDRESS | cast from-wei
    2echo `cast call $USDC_ADDRESS "balanceOf(address)" $ADDRESS | cast to-dec`/10^6 | bc

இப்போது நம்மிடம் WETH மற்றும் USDC இருப்பதால், நாம் உண்மையில் முகவரை இயக்கலாம்.

1git checkout 05-trade
2uv run agent.py

வெளியீடு இது போன்று இருக்கும்:

1(ai-trading-agent) qbzzt@Ori-Cloudnomics:~/260215-ai-agent$ uv run agent.py
2தற்போதைய விலை: 1843.16
32026-02-06T23:07-இல், எதிர்பார்க்கப்படும் விலை: 1724.41 USD
4வர்த்தகத்திற்கு முன் கணக்கு இருப்புகள்:
5USDC இருப்பு: 927301.578272
6WETH இருப்பு: 500
7விற்பனை செய், விலை 118.75 USD குறையும் என்று எதிர்பார்க்கிறேன்
8அனுமதி பரிவர்த்தனை அனுப்பப்பட்டது: 74e367ddbb407c1aaf567d87aa5863049991b1d2aa092b6b85195d925e2bd41f
9அனுமதி பரிவர்த்தனை மைன் செய்யப்பட்டது.
10விற்பனை பரிவர்த்தனை அனுப்பப்பட்டது: fad1bcf938585c9e90364b26ac7a80eea9efd34c37e5db81e58d7655bcae28bf
11விற்பனை பரிவர்த்தனை மைன் செய்யப்பட்டது.
12வர்த்தகத்திற்குப் பிறகு கணக்கு இருப்புகள்:
13USDC இருப்பு: 929143.797116
14WETH இருப்பு: 499
அனைத்தையும் காட்டு

இதை உண்மையில் பயன்படுத்த, உங்களுக்கு சில சிறிய மாற்றங்கள் தேவை.

  • வரி 14-இல், MAINNET_URL-ஐ https://eth.drpc.org போன்ற ஒரு உண்மையான அணுகல் புள்ளிக்கு மாற்றவும்
  • வரி 28-இல், PRIVATE_KEY-ஐ உங்கள் சொந்த தனிப்பட்ட விசைக்கு மாற்றவும்
  • நீங்கள் மிகவும் செல்வந்தராக இருந்து, நிரூபிக்கப்படாத ஒரு முகவருக்காக ஒவ்வொரு நாளும் 1 ETH வாங்கவோ அல்லது விற்கவோ முடியாவிட்டால், WETH_TRADE_AMOUNT-ஐக் குறைக்க 29-ஐ மாற்ற விரும்பலாம்

குறியீடு விளக்கம்

இதோ புதிய குறியீடு.

1SWAP_ROUTER_ADDRESS=Web3.to_checksum_address("0xE592427A0AEce92De3Edee1F18E0157C05861564")
2WETH_TO_USDC=bytes.fromhex("C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc20001F4A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48")
3USDC_TO_WETH=bytes.fromhex("A0b86991c6218b36c1d19D4a2e9Eb0cE3606eB480001F4C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2")
4PRIVATE_KEY="0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"

படி 4-இல் நாம் பயன்படுத்திய அதே மாறிகள்.

1WETH_TRADE_AMOUNT=1

வர்த்தகம் செய்ய வேண்டிய தொகை.

1ERC20_ABI = [
2    { "name": "symbol", ... },
3    { "name": "decimals", ... },
4    { "name": "balanceOf", ...},
5    { "name": "approve", ...}
6]

உண்மையில் வர்த்தகம் செய்ய, நமக்கு approve செயல்பாடு தேவை. நாம் முன்பும் பின்பும் இருப்புகளைக் காட்ட விரும்புகிறோம், எனவே நமக்கு balanceOf உம் தேவை.

1SWAP_ROUTER_ABI = [
2  { "name": "exactInput", ...},
3]

SwapRouter பயன்பாடு பைனரி இடைமுகம் (ABI)-இல் நமக்கு exactInput மட்டுமே தேவை. சரியாக ஒரு WETH-ஐ வாங்க நாம் பயன்படுத்தக்கூடிய exactOutput என்ற தொடர்புடைய செயல்பாடு உள்ளது, ஆனால் எளிமைக்காக நாம் இரண்டு நிகழ்வுகளிலும் exactInput-ஐ மட்டுமே பயன்படுத்துகிறோம்.

1account = w3.eth.account.from_key(PRIVATE_KEY)
2swap_router = w3.eth.contract(
3    address=SWAP_ROUTER_ADDRESS,
4    abi=SWAP_ROUTER_ABI
5)

கணக்கு (opens in a new tab) மற்றும் SwapRouter ஒப்பந்தத்திற்கான Web3 வரையறைகள்.

1def txn_params() -> dict:
2    return {
3        "from": account.address,
4        "value": 0,
5        "gas": 300000,
6        "nonce": w3.eth.get_transaction_count(account.address),
7    }

பரிவர்த்தனை அளவுருக்கள். ஒவ்வொரு முறையும் நான்ஸ் (opens in a new tab) மாற வேண்டும் என்பதால், இங்கு நமக்கு ஒரு செயல்பாடு தேவை.

1def approve_token(contract: Contract, amount: int):

SwapRouter-க்கு ஒரு டோக்கன் அனுமதியை அங்கீகரிக்கவும்.

1    txn = contract.functions.approve(SWAP_ROUTER_ADDRESS, amount).build_transaction(txn_params())
2    signed_txn = w3.eth.account.sign_transaction(txn, private_key=PRIVATE_KEY)
3    tx_hash = w3.eth.send_raw_transaction(signed_txn.raw_transaction)

Web3-இல் ஒரு பரிவர்த்தனையை இப்படித்தான் அனுப்புகிறோம். முதலில் பரிவர்த்தனையை உருவாக்க the Contract object (opens in a new tab) ஐப் பயன்படுத்துகிறோம். பின்னர் பரிவர்த்தனையில் கையொப்பமிட PRIVATE_KEY ஐப் பயன்படுத்தி web3.eth.account.sign_transaction (opens in a new tab) ஐப் பயன்படுத்துகிறோம். இறுதியாக, பரிவர்த்தனையை அனுப்ப w3.eth.send_raw_transaction (opens in a new tab) ஐப் பயன்படுத்துகிறோம்.

1    print(f"அனுமதி பரிவர்த்தனை அனுப்பப்பட்டது: {tx_hash.hex()}")
2    w3.eth.wait_for_transaction_receipt(tx_hash)
3    print("அனுமதி பரிவர்த்தனை மைன் செய்யப்பட்டது.")

w3.eth.wait_for_transaction_receipt (opens in a new tab) பரிவர்த்தனை மைன் செய்யப்படும் வரை காத்திருக்கிறது. தேவைப்பட்டால் அது ரசீதைத் திருப்பித் தருகிறது.

1SELL_PARAMS = {
2    "path": WETH_TO_USDC,
3    "recipient": account.address,
4    "deadline": 2**256 - 1,
5    "amountIn": WETH_TRADE_AMOUNT * 10 ** wethusdc_pool.token1.decimals,
6    "amountOutMinimum": 0,
7}

இவை WETH விற்கும் போது அளவுருக்கள்.

1def make_buy_params(quote: Quote) -> dict:
2    return {
3        "path": USDC_TO_WETH,
4        "recipient": account.address,
5        "deadline": 2**256 - 1,
6        "amountIn": int(quote.price*WETH_TRADE_AMOUNT) * 10**wethusdc_pool.token0.decimals,
7        "amountOutMinimum": 0,
8    }

SELL_PARAMS-க்கு மாறாக, வாங்குதல் அளவுருக்கள் மாறலாம். உள்ளீட்டுத் தொகை 1 WETH இன் விலை, இது quote-இல் கிடைக்கிறது.

1def buy(quote: Quote):
2    buy_params = make_buy_params(quote)
3    approve_token(wethusdc_pool.token0.contract, buy_params["amountIn"])
4    txn = swap_router.functions.exactInput(buy_params).build_transaction(txn_params())
5    signed_txn = w3.eth.account.sign_transaction(txn, private_key=PRIVATE_KEY)
6    tx_hash = w3.eth.send_raw_transaction(signed_txn.raw_transaction)
7    print(f"வாங்க பரிவர்த்தனை அனுப்பப்பட்டது: {tx_hash.hex()}")
8    w3.eth.wait_for_transaction_receipt(tx_hash)
9    print("வாங்க பரிவர்த்தனை மைன் செய்யப்பட்டது.")
10
11
12def sell():
13    approve_token(wethusdc_pool.token1.contract,
14                  WETH_TRADE_AMOUNT * 10**wethusdc_pool.token1.decimals)
15    txn = swap_router.functions.exactInput(SELL_PARAMS).build_transaction(txn_params())
16    signed_txn = w3.eth.account.sign_transaction(txn, private_key=PRIVATE_KEY)
17    tx_hash = w3.eth.send_raw_transaction(signed_txn.raw_transaction)
18    print(f"விற்பனை பரிவர்த்தனை அனுப்பப்பட்டது: {tx_hash.hex()}")
19    w3.eth.wait_for_transaction_receipt(tx_hash)
20    print("விற்பனை பரிவர்த்தனை மைன் செய்யப்பட்டது.")
அனைத்தையும் காட்டு

buy() மற்றும் sell() செயல்பாடுகள் கிட்டத்தட்ட ஒரே மாதிரியானவை. முதலில் நாம் SwapRouter-க்கு போதுமான அனுமதியை அங்கீகரிக்கிறோம், பின்னர் அதை சரியான பாதை மற்றும் தொகையுடன் அழைக்கிறோம்.

1def balances():
2    token0_balance = wethusdc_pool.token0.contract.functions.balanceOf(account.address).call()
3    token1_balance = wethusdc_pool.token1.contract.functions.balanceOf(account.address).call()
4
5    print(f"{wethusdc_pool.token0.symbol} இருப்பு: {Decimal(token0_balance) / Decimal(10 ** wethusdc_pool.token0.decimals)}")
6    print(f"{wethusdc_pool.token1.symbol} இருப்பு: {Decimal(token1_balance) / Decimal(10 ** wethusdc_pool.token1.decimals)}")

இரண்டு நாணயங்களிலும் பயனர் இருப்புகளைப் புகாரளிக்கவும்.

1print("வர்த்தகத்திற்கு முன் கணக்கு இருப்புகள்:")
2balances()
3
4if (expected_price > current_price):
5    print(f"வாங்கு, விலை {expected_price - current_price} USD உயரும் என்று எதிர்பார்க்கிறேன்")
6    buy(wethusdc_quotes[-1])
7else:
8    print(f"விற்பனை செய், விலை {current_price - expected_price} USD குறையும் என்று எதிர்பார்க்கிறேன்")
9    sell()
10
11print("வர்த்தகத்திற்குப் பிறகு கணக்கு இருப்புகள்:")
12balances()
அனைத்தையும் காட்டு

இந்த முகவர் தற்போது ஒரு முறை மட்டுமே வேலை செய்கிறது. இருப்பினும், நீங்கள் அதை crontab (opens in a new tab)-இலிருந்து இயக்குவதன் மூலமாகவோ அல்லது வரிகள் 368-400-ஐ ஒரு லூப்பில் வைத்து, அடுத்த சுழற்சிக்கான நேரம் வரும் வரை காத்திருக்க time.sleep (opens in a new tab)-ஐப் பயன்படுத்துவதன் மூலமாகவோ அதைத் தொடர்ந்து வேலை செய்யும்படி மாற்றலாம்.

சாத்தியமான மேம்பாடுகள்

இது ஒரு முழுமையான தயாரிப்பு பதிப்பு அல்ல; இது அடிப்படைகளைக் கற்பிப்பதற்கான ஒரு எடுத்துக்காட்டு மட்டுமே. மேம்பாடுகளுக்கான சில யோசனைகள் இங்கே உள்ளன.

புத்திசாலித்தனமான வர்த்தகம்

என்ன செய்ய வேண்டும் என்பதைத் தீர்மானிக்கும் போது முகவர் புறக்கணிக்கும் இரண்டு முக்கியமான உண்மைகள் உள்ளன.

  • எதிர்பார்க்கப்படும் மாற்றத்தின் அளவு. விலை குறையும் என்று எதிர்பார்க்கப்பட்டால், சரிவின் அளவைப் பொருட்படுத்தாமல் முகவர் ஒரு குறிப்பிட்ட அளவு WETH-ஐ விற்கிறது. சிறு மாற்றங்களைப் புறக்கணித்து, விலை எவ்வளவு குறையும் என்று நாம் எதிர்பார்க்கிறோம் என்பதன் அடிப்படையில் விற்பது நல்லது என்று வாதிடலாம்.
  • தற்போதைய போர்ட்ஃபோலியோ. உங்கள் போர்ட்ஃபோலியோவில் 10% WETH-இல் இருந்தால், விலை உயரும் என்று நீங்கள் நினைத்தால், மேலும் வாங்குவது அர்த்தமுள்ளதாக இருக்கும். ஆனால் உங்கள் போர்ட்ஃபோலியோவில் 90% WETH-இல் இருந்தால், நீங்கள் போதுமான அளவு வெளிப்பட்டிருக்கலாம், மேலும் வாங்க வேண்டிய அவசியமில்லை. விலை குறையும் என்று நீங்கள் எதிர்பார்த்தால் இதன் நேர்மாறானது உண்மை.

உங்கள் வர்த்தக உத்தியை ரகசியமாக வைத்திருக்க விரும்பினால் என்ன செய்வது?

AI விற்பனையாளர்கள் நீங்கள் அவர்களின் LLMகளுக்கு அனுப்பும் வினவல்களைப் பார்க்க முடியும், இது உங்கள் முகவருடன் நீங்கள் உருவாக்கிய மேதை வர்த்தக அமைப்பை வெளிப்படுத்தக்கூடும். பலர் பயன்படுத்தும் ஒரு வர்த்தக அமைப்பு பயனற்றது, ஏனெனில் நீங்கள் வாங்க விரும்பும் போது பலர் வாங்க முயற்சிப்பார்கள் (மற்றும் விலை உயரும்) மற்றும் நீங்கள் விற்க விரும்பும் போது விற்க முயற்சிப்பார்கள் (மற்றும் விலை குறைகிறது).

இந்த சிக்கலைத் தவிர்க்க, நீங்கள் உள்நாட்டில் ஒரு LLM-ஐ இயக்கலாம், எடுத்துக்காட்டாக, LM-Studio (opens in a new tab)-ஐப் பயன்படுத்தி.

AI பாட்-டிலிருந்து AI முகவருக்கு

இது ஒரு AI பாட், AI முகவர் அல்ல என்பதற்கு நீங்கள் ஒரு நல்ல வாதத்தை முன்வைக்கலாம். இது முன்னரே வரையறுக்கப்பட்ட தகவலை நம்பியிருக்கும் ஒப்பீட்டளவில் எளிமையான உத்தியைச் செயல்படுத்துகிறது. உதாரணமாக, Uniswap v3 பூல்களின் பட்டியலையும் அவற்றின் சமீபத்திய மதிப்புகளையும் வழங்கி, எந்தக் கலவை சிறந்த முன்கணிப்பு மதிப்பைக் கொண்டுள்ளது என்று கேட்பதன் மூலம் நாம் சுய-முன்னேற்றத்தை இயக்கலாம்.

ஸ்லிப்பேஜ் பாதுகாப்பு

தற்போது எந்த ஸ்லிப்பேஜ் பாதுகாப்பும் (opens in a new tab) இல்லை. தற்போதைய மேற்கோள் $2000 ஆக இருந்து, எதிர்பார்க்கப்படும் விலை $2100 ஆக இருந்தால், முகவர் வாங்கும். இருப்பினும், முகவர் வாங்குவதற்கு முன்பு விலை $2200 ஆக உயர்ந்தால், இனி வாங்குவதில் அர்த்தமில்லை.

ஸ்லிப்பேஜ் பாதுகாப்பைச் செயல்படுத்த, agent.py (opens in a new tab)-இன் 325 மற்றும் 334 வரிகளில் ஒரு amountOutMinimum மதிப்பைக் குறிப்பிடவும்.

முடிவுரை

நம்புகிறோம், இப்போது நீங்கள் AI முகவர்களுடன் தொடங்குவதற்கு போதுமான அளவு அறிந்திருப்பீர்கள். இது இந்த விஷயத்தின் முழுமையான கண்ணோட்டம் அல்ல; அதற்காக முழு புத்தகங்களும் அர்ப்பணிக்கப்பட்டுள்ளன, ஆனால் இது நீங்கள் தொடங்குவதற்கு போதுமானது. நல்ல அதிர்ஷ்டம்!

எனது மேலும் பணிகளை இங்கே பார்க்கவும் (opens in a new tab).

பக்கத்தின் கடைசி புதுப்பிப்பு: 10 பிப்ரவரி, 2026

qbzztq (opens in a new tab)
wackeroww (opens in a new tab)
OP (opens in a new tab)

இந்தப் பயிற்சி உதவியாக இருந்ததா?