AutoGen ચુકવણી એકીકરણ.
કોઈ AutoGen પેકેજ નથી, અને તમને એકની જરૂર નથી. વાસ્તવિક blockchain0x ક્લાયન્ટને એક કાર્યમાં લપેટો, તેને તમારા એજન્ટને આપો, અને તે Base પર USDC ખસેડી શકે છે.
કોઈ AutoGen-specific package નથી, અને તમને તેની જરૂર પણ નથી. AutoGen પહેલેથી જ plain typed function ને tool માં ફેરવે છે, તેથી તમે real Python client ને function માં wrap કરો છો, તેને ને મારફતે આપો છો, અને agent Base પર USDC મોકલી શકે છે, invoices settle કરી શકે છે, અને wallets વાંચી શકે છે. સેટ કરો અને શરૂ કરો.
AutoGen પહેલેથી જ એક ફંક્શનને ટૂલ બનાવે છે. તેનો ઉપયોગ કરો.
AutoGen એક ટૂલ સ્કીમાને સીધા Python ફંક્શનના સહી અને ડોકસ્ટ્રિંગમાંથી બનાવે છે. એક નિર્ધારિત AutoGen એડેપ્ટર ફક્ત એક ફંક્શનને લપેટશે જે અમે કોઈપણ રીતે લખી શકતા, પછી AutoGenની ઝડપી ચલતી API સાથે અસંકલિત થઈ જશે. તેથી અમે એક મોકલતા નથી. તમે થોડા લાઇન લખો જે વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરે છે, અને તમે આર્ગ્યુમેન્ટ્સ, માન્યતા, અને ભૂલ હેન્ડલિંગ પર સંપૂર્ણ નિયંત્રણ રાખો છો.
આ એ જ ક્લાયન્ટ છે જે મોકલવામાં આવેલા LangChain અને CrewAI એડેપ્ટર્સ હેન્ડલ હેઠળ લપેટે છે. અહીં તમે તેને તમારી જાતે લપેટો છો, જેનો અર્થ એ છે કે ટ્રેક કરવા માટે કોઈ એડેપ્ટર સંસ્કરણ નથી અને તમારા એજન્ટ અને API વચ્ચે તમારી પોતાની કાર્ય સિવાય કંઈ નથી. મલ્ટી-એજન્ટ ટીમો આ જ રીતે કાર્ય કરે છે: એક એજન્ટને વોલેટ કાર્ય આપો, અન્યને તેના વગર છોડી દો, અને ખર્ચની સત્તા એક જ જગ્યાએ રહે છે.
AutoGen અને મુખ્ય SDK સ્થાપિત કરો. એક પર્યાવરણ ચલ.
જોડવા માટે કોઈ સમર્પિત AutoGen પેકેજ નથી. તમે AutoGen (Python 3.10+) અને વાસ્તવિક blockchain0x મુખ્ય SDKને ઇન્સ્ટોલ કરો છો, પછી નીચેનું કાર્ય લખો. તે સમગ્ર નિર્ભરતા યાદી છે.
pip install autogen-agentchat "autogen-ext[openai]" blockchain0x
export BLOCKCHAIN0X_API_KEY=sk_test_... # sk_test_ = Base Sepolia, sk_live_ = Base mainnet
BLOCKCHAIN0X_API_KEY તમારા dashboardમાંથી મળતી sk_test_ testnet અથવા sk_live_ mainnet key છે; client તેને environmentમાંથી વાંચે છે. જો તમારો agent પૈસા પણ મેળવે છે, તો webhook handler ને વધારામાં BLOCKCHAIN0X_WEBHOOK_SECRETની જરૂર પડશે, જે webhook create અથવા rotate કરતાં dashboard એકવાર આપે છે.
એક ફંક્શન જે ચૂકવણી કરે છે, તે AssistantAgentને સોંપવામાં આવે છે.
નીચે સમગ્ર એકીકરણ છે. send_usdc વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરે છે; AssistantAgent(tools=[send_usdc]) તેને એક સાધનમાં ફેરવે છે જે મોડલ કોલ કરી શકે છે. AutoGen પ્રકારના સંકેતો અને ડોકસ્ટ્રિંગને વાંચે છે જેથી સ્કીમા બનાવવામાં આવે, તેથી તેમને ઈમાનદાર રાખો. તેને ચલાવો અને એજન્ટ Base પર USDC ખસેડે છે.
from autogen_agentchat.agents import AssistantAgent from autogen_ext.models.openai import OpenAIChatCompletionClient from blockchain0x import Client blockchain0x = Client() # reads BLOCKCHAIN0X_API_KEY from the environment # AutoGen turns a plain typed function into a tool. No dedicated package needed. def send_usdc(agent_id: str, to: str, amount_wei: str) -> str: """Send a USDC payment from an agent wallet. amount_wei is USDC base units (6 decimals), so "10000" is 0.01 USDC. """ result = blockchain0x.payments.create( body={"agentId": agent_id, "to": to, "amountWei": amount_wei}, ) return str(result) treasurer = AssistantAgent( name="treasurer", model_client=OpenAIChatCompletionClient(model="gpt-4o"), tools=[send_usdc], system_message="You pay vendor invoices in USDC within owner-set limits.", ) result = await treasurer.run( task="Pay 0.01 USDC from agent agt_123 to 0xVendor for the dataset.", )
When the agent decides to pay, it calls send_usdc, the SDK submits the transfer, and you get a transaction hash back. amount_wei is base units, so 0.01 USDC is "10000". A sk_test_ key keeps it on Base Sepolia until you switch to sk_live_. Add more functions - read a wallet, settle an invoice - the same way; each becomes another entry in tools.
સહી કરેલ વેબહૂક સાથે ઇનબાઉન્ડ ચુકવણીઓની પુષ્ટિ કરો.
જો તમારો એજન્ટ પણ USDC પ્રાપ્ત કરે છે, તો તેને વેબહૂક સાથે પુષ્ટિ કરો, પોલિંગ દ્વારા નહીં. ચકાસણી સહાયક નોડ SDK માં શિપ થાય છે; એક પાયથન સેવા માં તમે દસ્તાવેજિત HMAC સામે હાથથી ચકાસો છો, જે સહાયક કરે છે. નીચેનું ફાસ્ટએપીઆઈ ઉદાહરણ; તે જ કોડ કોઈપણ અસિંક પાયથન ફ્રેમવર્કમાં કાર્ય કરે છે.
import hmac, hashlib, os, time from fastapi import FastAPI, Request, HTTPException app = FastAPI() SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode() @app.post("/webhooks/payment") async def receive(request: Request): raw = await request.body() # RAW bytes - do not parse first sig = request.headers.get("X-Blockchain0x-Signature", "") ts = request.headers.get("X-Blockchain0x-Timestamp", "") parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p) t, v1 = parts.get("t", ts), parts.get("v1", sig) want = hmac.new(SECRET, t.encode() + b"." + raw, hashlib.sha256).hexdigest() if not hmac.compare_digest(want, v1) or abs(time.time() - int(t)) > 300: raise HTTPException(status_code=401) if request.headers.get("X-Blockchain0x-Event-Type") == "payment.received": await trigger_followup() # USDC landed - run the next step return {"ok": True}
અલ્ગોરિધમ t.rawBody પર HMAC-SHA256 છે, એક સ્થિર-સમયની તુલના, અને 300-સેકન્ડનું પુનરાવર્તન વિન્ડો. કાચી બોડીને await request.body() દ્વારા વાંચો, ક્યારેય request.json() ફરીથી-સિરિયલાઇઝ ન કરો, કારણ કે તે સહીના કવર કરેલા બાઇટ્સને બદલે છે. શિપ કરેલ ઇવેન્ટ્સ છે payment.received, payment.sent, wallet.deployed, અને webhook.test. ભારે અનુસરણ કાર્ય માટે, એક નોકરી (Celery, RQ, arq) એન્ક્યૂ કરો અને હેન્ડલરને બ્લોક કરવા કરતાં તરત 200 પ્રતિસાદ આપો.
તમે લપેટી રહેલા ક્લાયન્ટ ખુલ્લા છે. તેને વાંચો.
ક્લોન કરવા માટે કોઈ AutoGen starter package નથી - ઉપર આપેલું recipe જ integration છે. blockchain0x SDKs GitHub પર open source છે; આ recipe Python SDK (blockchain0x-python)ને wrap કરે છે, અને સંપૂર્ણ method surface docsમાં છે. function bodies માટે reference તરીકે તેને વાંચો.
github.com/tosh-labs/blockchain0x-pythonસંપૂર્ણ SDK method surface અને scopes the docsમાં documented છે. Base Sepolia સામે sk_test_ keyથી શરૂ કરો, પછી function અપેક્ષા મુજબ કામ કરે ત્યારે sk_live_ પર switch કરો.
પાંચ ગ્રુપ-ચેટ અને અસંક્રામક જાળાઓથી બચવું.
AutoGen નો મલ્ટી-એજન્ટ + અસિંક ડિઝાઇન શક્તિશાળી પેટર્નને અનલોક કરે છે પરંતુ તેના પોતાના ફૂટગન્સ રજૂ કરે છે. આ અમારા સપોર્ટ ઇનબોક્સમાંથી આવે છે.
કોઈ AutoGen પેકેજ નથી - તમે SDK ને લપેટો છો
Blockchain0x LangChain અને CrewAI માટે એડેપ્ટર્સ મોકલે છે અને MCP સર્વર; ત્યાં કોઈ સમર્પિત AutoGen પેકેજ નથી. ઉપરનો નુસખો માર્ગ છે: એક સાદી ટાઇપ કરેલ કાર્ય જે વાસ્તવિક blockchain0x ક્લાયન્ટને કોલ કરે છે, જે AssistantAgent(tools=[...])ને સોંપવામાં આવે છે. AutoGen કાર્યના હસ્તાક્ષર અને ડોકસ્ટ્રિંગને વાંચે છે જેથી સાધન સ્કીમા બનાવવામાં આવે, તેથી ડોકસ્ટ્રિંગને ચોક્કસ રાખો.
રકમ USDC આધાર એકમો છે, સ્ટ્રિંગ્સ તરીકે
payments.create takes amountWei: a string of USDC base units, not a float and not a dollar figure. USDC has 6 decimals, so 0.01 USDC is "10000" and 5 USDC is "5000000". Type the tool argument as str and validate it before the call - a float that sneaks through either errors at the backend or moves a millionth of what you meant.
send_payment વહેલા 503 જવાબ આપી શકે છે
payments.create ડિફોલ્ટ દ્વારા પુનરાવૃત્ત નથી કરે અને તમારા નેટવર્ક માટે ચેઇન એડેપ્ટર વાયર કરવામાં આવે ત્યાં સુધી 503 પાછું આપી શકે છે. નિષ્ફળ ચુકવણી પર ગ્રુપ ચેટને લૂપ પર મૂકવા દેતા નથી - તમારી ફંક્શનની અંદર ભૂલને પકડો, મોડેલ કાર્ય કરી શકે તેવા સ્પષ્ટ સંદેશાને પાછું આપો, અને આપોઆપ મિન્ટ કરેલ idempotency કી પર આધાર રાખો જેથી મેન્યુઅલ પુનરાવૃત્તિ ડબલ-ચુકવણી ન કરે.
AutoGen 0.4+ અસંકલિત છે; SDK કોલ સંકલિત છે
AutoGen 0.4 ટૂલ્સને અસંકલિત લૂપમાં ચલાવે છે. blockchain0x ક્લાયન્ટ કોલ સંકલિત છે, જે ઝડપી વિનંતી માટે યોગ્ય છે, પરંતુ ધીમી કોલ લૂપને રોકે છે. જો તમે વાસ્તવિક વોલ્યુમ ખસેડી રહ્યા છો, તો SDK કોલને asyncio.to_thread સાથે લપેટો જેથી ઇવેન્ટ લૂપ પ્રતિસાદી રહે. એક જ ફેરફાર માટે એક જ ચુકવણી માટે, તેને સીધા કોલ કરવું યોગ્ય છે.
કાચા બોડી સામે આવતી વેબહુક્સની પુષ્ટિ કરો
જો તમારો એજન્ટ પણ પૈસા પ્રાપ્ત કરે છે, તો તેને વેબહૂક સાથે પુષ્ટિ કરો, પોલિંગ દ્વારા નહીં. RAW વિનંતી બાઇટ્સ (await request.body()) પર સહીને ચકાસો, ક્યારેય request.json() પુનઃસિરિયલાઇઝ ન કરો, કારણ કે HMAC ચોક્કસ બાઇટ્સને આવરી લે છે. તે HMAC-SHA256 છે જે 300-સેકન્ડ રિપ્લે વિન્ડો સાથે છે. નીચેનો હેન્ડલર આખું છે.