Taky

Code, Quant

[wishful_cynic @EvgenyGaevoy]

really wish we have more comms like this in crypto

[Taky @20quant]

@ki_young_ju @Bybit_Official At that size it looks more like them testing frequency

[Taky @20quant]

@ki_young_ju Plz do 100$ per month and hence filter out those willing to give meaningful comments

[otw2 @imotw2]

a thread on different kinds of edges, why the disappear, and why they sometimes don’t

1/n

[GodRama @GodRama_]

After achieving my $10,000 goal on @Polymarket .

I decided to make a list with the tools i use the most!

1) @StandDOTtrade : The first tool i used starting my journey on polymarket . This tool is realy good to track wallets and get notifications on Discord , it comes really handy if you have some insider wallets to see when they are acting.

2)@betmoardotfun : This is a great discord bot providing PNL charts , updates , market orderbooks it helps me see markets when i am trading from a phone much faster than actually searching on polymarket.

3)@Polysights : This one is pretty obvious i think , Insider finder is truly a great tool i use daily to check for any suspicious activity on markets.

4)@MentionsPro : This tool came to my hands about 2 months ago . I now use it daily to find mispriced markets on mentions markets , it saves me a ton of time everyday . Instead of having to search multiple transcripts everything is in there.

Hope this one helps new people on @Polymarket . Feel free to share your list below .

Polymarket supercycle.

[ᗪ ᑕ ᑕᖇYᑭT 🥷 @DC__CRYPT]

Today I received a message questioning the $ASTER buybacks, implying that they're making transactions between various wallets and not actually repurchasing, and that it's unknown where they're buying from (spoiler: Pancakeswap).

So I've chosen a random buyback transaction and I'm going to explain the whole process to understand what's happening internally on the blockchain and put an end to the unfounded FUD. Before accusing someone, you should learn to read the blockchain.

- This is the transaction: https://t.co/KaVrchFiRk

Step-by-step explanation of each of the operations within the transaction:

🔸1. The transaction begins with the entry of funds and the preparation of the stable tokens (BUSD) that will be used for the purchase:

- Movement 1 and 2 (BUSD Entry):
Aster: Buyback 2 sends 5,000 BUSD to the address 0xa6F7444D...671e63994.

Immediately, this address transfers the 5,000 BUSD to another address, 0x1A2bb6B7...a3F637940.

Interpretation: The address 0x1A2bb6B7...a3F637940 (the main operational address) is being funded with BUSD.

🔸The core of the transaction is the exchange involving PancakeSwap:

- Movement 3 (ASTER Sale/Entry to Swap):
The address 0xaeaD6bd3...61585b0b1 sends 4,974.38 ASTER to the exchange contract PancakeSwap: Universal Router 2.

Interpretation: This is the selling side or liquidity provision of ASTER.

- Movement 4 (ASTER Purchase/BUSD Exit):
The main operational address, 0x1A2bb6B7...a3F637940 (holding the 5,000 BUSD), sends 5,000 BUSD to the address 0xaeaD6bd3...61585b0b1.

Interpretation: This is the counterpart of the exchange: the BUSD is sent to the address that sold/provided ASTER. The address 0x1A2bb6B7...a3F637940 has effectively purchased ASTER through this process.

🔸After the exchange, the acquired ASTER is distributed or utilized:

- Movement 5 and 6 (Distribution of Acquired ASTER): The PancakeSwap Router sends two quantities of ASTER from the swap: 12.43 ASTER to the address 0xfeE0000a...8872b7F02. (A small distribution/fee). 4,961.94 ASTER to the main operational address, 0x1A2bb6B7...a3F637940. (The bulk of the purchase).

- Movement 7, 8 and 9 (Buyback and Internal Movement): The main address, 0x1A2bb6B7...a3F637940, sends the acquired 4,961.94 ASTER to the address 0xa6F7444D...671e63994. This address, 0xa6F7444D...671e63994, splits the ASTER into two: A very small amount, 0.25 ASTER, is sent to the address 0xA05405b6...b1F028359. The vast majority, 4,961.69 ASTER, is sent to the contract Aster: Buyback 2.

Interpretation: The Buyback has been executed: The ASTER acquired with the 5,000 BUSD has been returned to the buyback contract.

🔸The final movements: fee, or very small balance adjustments transactions involving other stable tokens (USDC) and WBNB:

- Movement 10 to 14 (ASTER/USDC/BUSD Adjustments): There is a series of micro-transactions (0.25 ASTER/USDC/BUSD) between the internal addresses (0xA05405b6..., 0x1A2bb6B7..., 0x27d90157...) and the PancakeSwap Router.

Interpretation: These are likely fee adjustments, dust (small remaining amounts), or gas payments being settled through the same transaction.

- Movement 15 to 18 (WBNB Usage): The last movements show a tiny amount of Wrapped BNB (WBNB), also valued at $0.25, being used between a new address (0x172fcD41...) and the main operational address (0x1A2bb6B7...), ending up in the adjustment address (0xA05405b6...).

Interpretation: It is very common for gas fees on BSC to be paid in BNB, and WBNB (the tokenized version of BNB) is often used to settle fees or minor balances within smart contracts.

➡️ CONCLUSION: Blockchain is difficult to understand from a technical point of view, but it's transparent and doesn't deceive. Everything else is unfounded FUD born of ignorance. And the worst part is that it's the #ASTER holders themselves, driven by their impatience, who are sowing these doubts. Do some research and learn before spreading your misinformation online and shooting yourself in the foot.

📤 Share by reposting

#AsterDex

[BlockSec @BlockSecTeam]

https://t.co/Ph88jLQ7lC

[Weilin (William) Li @hklst4r]

I have made a thorough analysis of the @Balancer attack: https://t.co/FSLNEZJspD
---

Yesterday, on July 3, 2025, Balancer was hacked for over $100 million due to a precision-loss bug.
While the official post-mortem hasn’t been released yet, most pools are already paused or drained(https://t.co/m6AqY3NnPb). This post is my own analysis of the exploit.

In this blog, I will:
- identify the root cause,
- analyze the copycats,
- and discuss how to profit (not by hacking!).

I. Attack Analysis
Initially, several security researchers claimed the exploit was merely an access-control bug similar to the Abracadabra attack (e.g., https://t.co/ssk4saQ2Wg).

However, the transactions they posted were just the withdrawals, not the actual exploit. For example:
- This is the withdraw transaction: https://t.co/cKDy9ZNsix
- This (the contract creation) is the attack transaction: https://t.co/Tx8o3jIAhc

Balancer has an advanced internal balance feature (which is actually not vulnerable) allows users to perform internal accounting instead of ERC-20 transfers.
For instance, when swapping ETH → DAI → USDC, the DAI transfer may never appear on-chain because the balance is updated internally.
Users can also deposit or withdraw their internal balances anytime. The hacker’s withdrawal transaction was simply such a withdrawal.

First question, why does the hacker split the attack into 2 steps (attack-then-withdraw)? Despite technical problems, one particular reason might be that this can partially mitigate front-running as the attack transaction is "not profitable" to some of the front runners unless they taken balancers' internal balance into consideration. However, he was still front-run by several bots as discussed later.

---
The vulnerability lies in precision loss within Balancer's Composable Stable Pool implementation — a modified version of Curve’s StableSwap AMM.

These pools contain multiple pegged assets (e.g., wstETH, ETH), and the LP token (BPT) can itself be swapped within the pool.
Swapping BPT → token1 effectively withdraws liquidity and swaps another token internally.

Balancer introduced a scaling factor to support related (not 1:1) assets.
For example, if 1 wstETH = 1.05 ETH, then:

- scaling factor of wstETH = 1.05
- scaling factor of ETH = 1.0

These are stored as integers in 1e18 precision (e.g., 1.05 × 10¹⁸ = 105e16).

The scaled amount is calculated as:

scaled_amount = (raw_amount * scaling_factor) / 1e18

Here comes the problem:

If raw_amount is very small (e.g., 8 wei), integer division causes precision loss of up to 12.5% (1/8).
Another contributing factor is the internal balance mechanism — users can flash-mint tokens during a `batchSwap`, use them within the same transaction, and only need to settle balances by the end. This made the exploit even more powerful.

---

Now, let's check into the attack transaction itself. We can take 0xe9245fb124c3a6ff6a0e39c6d0db02b74b3a3d805f6bf016f4b9ac56cbfb73ae on base as an example. On a high level, the attack was split into 4 phases (1 calculation + 3 actions).

1. Calculation

The attacker uses a standalone contract to simulate the swap states to trigger the exactly precision loss. This contracts' code is copied from the Balancers' own contracts because it also contains some custom errors in Balancers' code.

2. Manipulation

The attacker uses "flash-minted" LP token to manipulate the pool state by swapping BPT → token1 and BPT → token2 repeatedly, making the pools' raw balances very small (in the order of 10,000~100,000). As the flash-minted BPT cannot be withdrawn, the attacker needs to swap them to token1 and token2. After manipulation, as shown in the figure below, the raw balances of token1 and token2 are very small (40,000). This is the first parameter (we can call it b_init).

3. Precision-Loss Loop

The attacker repeatedly swapped between the two tokens to amplify the precision loss.
They optimized a variable s satisfying:

maximize{ (s * scaling_factor) % 1e18 }

This will create the maximum precision loss when swapping s amount of token1 to token2 or vice versa.
Specifically, one iteration contains 3 swaps:
A. `token1 → token2`: swap b_init tokens to create the precision condition
B. `token1 → token2`: swap s tokens to trigger precision loss
C. `token2 → token1`: swap ~90% back to restore balance

Each loop caused a small but compounding imbalance, roughly proportional to 1/s.
The attacker repeated this until the profit margin was large enough.

4. repay
The attacker finally swaps the remaining token1 and token2 back to BPT to repay the flash-minted LP tokens. This process also needs to be gentle to avoid large price impact. This is part of the withdrawing process as loss is already realized.

After that, they withdrew all tokens from internal balances — the withdrawal many researchers initially misidentified as the attack itself.

II. A Speed Run Copycat Game

While the main hacker only exploited some of the largest pools on Balancer, there were still food left on the table, extracted by whitehats, copycat attackers, and some MEV bots. These include:

- some small pools not gained by the main attacker;
- the “dead body” of the bigger pools;
- Balancer forks.

1. Front-running
While the attack implementation is complicated, the attacker has put his calculation contract on-chain. On the one hand, this avoids mismatch of state between off-chain calculation and on-chain execution; on the other hand, this also allows others to copy the attack easily. As a result, there are several [front-runners](https://t.co/zZyhyG0zCC) who front-run the main attacker to gain some profit.

Interestingly, the attacker, while creating this masterpiece hack, does not appear to be experienced. Evidences:
- The attacker could have used flashbots or directly submit to builders to avoid front-running, but he did not.
- The attacker left some debugging code (foundry logs) in the execution contract which could have been deleted. https://t.co/q9D8hFoAKG
- The hacker took quite a long time (around 20 minutes) to finish all the attacks across ethereum, optimism, arbitrum, polygon, etc.

2. Back-running - Copycats
One noting thing is that the attack is too complicated to implement because all the steps need to be precisely calculated to trigger the precision loss. Despite this, the very first copycat (https://t.co/D9kcNMfUIX) (by the way, he seems to be a notorious copycat, who also copied the squid bridge attack recently) started exploiting within one hour after the main attack (07:46 UTC -> 08:39 UTC)

How could this be possible? After checking the log of the copycat's transaction, you can find all the logging info from the attacker's contract, meaning the copycat just copied the attacker's contract code and deployed it by himself! So just by replacing the pool address and sender address, the copycat can launch the same attack, with super low effort.

In the following several hours, a large number of copycats appeared, exploiting various pools on Balancer. However, no exceptionally, all the copycats used the same code base as the original attacker, just changing the pool address and sender address.

3. Fork Fallout
Next the disaster comes to Balancer forks. As Balancer is open source, several forks have been created in the past years, including Beets, BEX, PHUX, etc. According to DeFiLlama's data, there are 27 Balancer V2 forks. (however, only V2 stable pools are vulnerable)

The largest fork, BEX, was also affected and exploited for around $13 million. BEX is the largest DEX on Berachain and has a large number of stable pools. As a result, berachain paused their chain to avoid attackers bridging assets out. Other forks, such as Beets on Sonic & Optimism, also suffered from the same precision loss attack.
It was a dark day for DeFi, a single precision loss bug replicated across multiple chains and protocols.
Even ETH’s price dropped shortly after, possibly related.

4. Pausing
You might ask, why didn't Balancer just pause the pools after they are aware of the vulnerability? The reason is that they did pause some of the pools, however, Balancer tries to be "decentralized" so that the pool's parameters and pausing state can only be changed within a window of deployment. This means if the pool is deployed for a long time, it cannot be paused anymore. Unfortunately, some of the vulnerable pools have already passed the pausing window, so Balancer cannot pause them anymore.

III. How to profit (not hacking!)

After I see on Twitter that Balancer was hacked, I was trying to figure out where I can short $BAL token. Unluckily, the only CEX/DEX is Mexc where there is no much liquidity. While I was searching, I realized I could short $BERA because BEX is the largest Balancer fork and it was also affected by the same vulnerability.

Another opportunity is to trade on this Polymarket market: https://t.co/2AWoqPVjiX. It remained a low price within 10 minutes after the attack happened, as reported by Defimon.

IV. Other analysis I find useful
- @KaihuaQIN from D23E: https://t.co/jjHIZrzwgK
- @TycheKong from SlowMist: https://t.co/puoe96AeE1
- @Phalcon_xyz Blocksec: https://t.co/uv0orZRWgf

---
Please follow me for more DeFi hack analysis and shitposting. : )

[Arthur Hayes @CryptoHayes]

你好PBOC , welcome to the money printing jamboree.

[Ash @ahboyash]

AI Agent Interoperability Standards

AgentFi standards are quietly becoming the base primitives.

Standards are emerging for AI agent communication and commerce (payments), addressing different layers of the interoperability stack.

This piece covers 6 major standards that allow for composability → Payments (x402), tools (MCP), checkout (Stripe ACP), coordination (Google A2A), trust (ERC-8004), and verifiable agent commerce (Virtuals ACP).

*Do note that all standards carry some amount of risks, from technical vulnerabilities to regulatory uncertainties and this requires careful implementation and ongoing monitoring.

- - - - -

a) x402: HTTP-Native Payments for AI Agents
• x402 revives the long dormant HTTP 402 "Payment Required" status code to enable instant micropayments directly over HTTP without accounts or subscriptions
• Developed by @coinbase with the x402 Foundation (partners: @Cloudflare, @Visa, @Google), it addresses the internet's lack of native payment capability and enables payments as low as $0.001 with ~2-second settlement times
• The flow: AI agent or user sends standard HTTP request → returns HTTP 402 with with JSON PaymentRequirements specifying amount, network, recipient address, and asset (typically stablecoins, USDC) → client signs payment tx using EIP-3009 (EVM) or SPL (Solana) authorization → which is then verified by the server (locally or facilitator's endpoint) Server Verification → tx is settled and the on-chain confirmation is triggered
• The protocol uses ERC-3009 for gasless EVM transfers, enabling clients to pay without holding ETH for gas.
• Settlement Times are ~2 seconds on @base (1-3 blocks) and sub-second on @solana with extremely low gas fees (<$0.0001 on Base, ~$0.01 on Solana); gasless for end users and no protocol fees
• Some recent integration examples include Cloudflare Agents SDKs (edge compute payments) and @virtuals_io with a 5x increase in agent transactions
• Risks: there was a 402bridge hack with the exploit resulting in $18k USDC stolen from users (attackers exploited backend private keys and token approvals to drain funds). There is also AI agent specific risks such as LLM manipulation (prompt injection attacks could expose seed phrases/ private keys or redirect payments to attackers’ address), agents may execute unauthorised transactions if consent mechanisms fail, and backend key management vulnerability
• An interesting concern is the AML/KYC requirements where CDP facilitator includes mandatory KYT/OFAC screening for USDC compliance, but x402's pseudonymous nature enables potential money laundering in AI agent transactions. Cross-border micropayments may trigger Money Transmitter License requirements in various jurisdictions. Another question to post is whether stablecoin regulations (MiCA in EU) directly apply to USDC transactions on-chain.
• Right now, x402 is limited to Base and Solana, where other chains need to self-host facilitators. EVM chains need EIP-3009 support, limiting token compatibility. There is also heavy reliance on Coinbase CDP and third-party facilitators which creates centralization risks despite a relatively open protocol design

b) ERC-8004: Blockchain-Based Trust for AI Agents
• ERC-8004 is a @ethereum Improvement Proposal (EIP) extending Google's A2A protocol with blockchain-based trust mechanisms → solves the trust problem through on-chain identity and reputation registries
• Three lightweight on-chain registries:
>> Identity registry: Portable agent IDs are ERC-721 NFTs linking to off-chain Agent Cards on IPFS (metadata) that store agent details, endpoints, and trust models with cross-chain and ENS/DID support
>> Reputation registry: Tracks performance via on-chain feedback scores from verified interactions. Feedback authorization secures reviews with EIP-191/ERC-1271 signatures, stores scores on-chain with IPFS feedback, and uses pre-authorization to prevent spam
>> Validation registry: Verification requests let agents submit task hashes for third-party scoring with proof links, supporting both pass/fail and multi-validator evaluations
• Interoperability mechanisms include oracle integration @LayerZero_Core, @chainlink CCIP for cross-chain data queries + Wrapped IDs for @solana/ @cosmos
• Risks include smart contracts threats like domain squatting, Sybil spam, and oracle tampering, while blockchains add MEV and storage bloat risks

Together, x402 and ERC-8004 creates the "ultimate app store" for AI agents on Ethereum → a coordination layer where agents can discover each other through ERC-8004 registries, establish trust through reputation systems, and transact with one another seamlessly through x402 payment rails

c) MCP (Model Context Protocol): Universal AI-Tool Integration
• Developed by @AnthropicAI, MCP serves as "USB-C for AI," standardising connections between AI apps and external systems through a client-server architecture
• The protocol operates in two layers: Data Layer (communication between clients and servers) and the Transport Layer (supports both low-latency local connections via Stdio Transport and remote streaming via HTTP)
• Adoption uses cases include @OpenAI (integration across ChatGPT, Agents SDK), @GoogleDeepMind (@GeminiApp models), @Microsoft (@Azure OpenAI Service) and @AnthropicAI (Native @claudeai Desktop integration)
• Risks include code execution via local servers to injection and DNS rebinding vulnerabilities. Authentication flaws like static client IDs, excessive permission scopes, and token passthroughs can enable unauthorised access and large-scale breaches. Lastly, privacy leaks and compliance violations expose enterprises to regulatory and supply-chain risks, as seen in real-world MCP and server compromises

d) Stripe ACP (Agentic Commerce Protocol): Agent-Driven Commerce
• @stripe's ACP is an open-source specification enabling secure, programmatic commerce between AI agents and merchants.
• Standardises how agents talk to online stores, manage carts, and pay using temporary encrypted tokens (SPTs) instead of users’ real card details
• The flow: AI agent sends checkout request with product intent which the merchant validates and responds with pricing → user selects preferences confirms via agent authorisation → Merchant creates payment intent and confirms order
• Security mechanisms include encryption & tokenisation (SPTs encrypt credentials, never expose raw payment data) and authentication (HTTPS + Bearer tokens, HMAC-signed webhooks)
• Partnerships include ChatGPT Integration (instant checkout), merchant access (with @Etsy and Shopify) → Stripe implementations could have significant ecosystem advantages with their many partnerships
• Risks includes bot manipulation (automated attacks exploiting agent payment flows), social engineering (tricking the AI agent into unauthorised purchases) and unclear ownership/ responsibilities (ambiguous responsibility for AI agent errors)

e) Google A2A (Agent2Agent): Multi-Agent Coordination
• @Google's Agent2Agent protocol enables opaque AI agent interoperability → a payment-agnostic framework to transact across all types of payment
• The goal is to build a shared protocol that provides a common language for secure, compliant transactions between agents and merchants, helping to prevent a fragmented eco
• There are over 150+ partner organizations including enterprise SaaS (Adobe, Salesforce, SAP, ServiceNow). Some early implementations include supply chain (Tyson Foods) and enterprise workflows (@Adobe content workflows and @ServiceNow automation)
• Security and attack vectors include identity attacks like agent card spoofing (malicious servers impersonating legitimate agents) and protocol level vulnerabilities (rug pulls, context positioning and redirection of workflows). There is also the case where it leads to protocol fragmentation (many different standards creating ecosystem fragmentation)

f) Virtuals ACP (Agent Commerce Protocol): Verifiable Agent Transactions
• @virtuals_io’s (ACP) creates a decentralised infrastructure where autonomous AI agents operate as tokenised, revenue-generating economic entities.
• The platform integrates multiple components for comprehensive agent lifecycle management:
>> The platform unifies agent lifecycle management through a 4-phase workflow → request, negotiation, transaction, and evaluation. All this is governed by the GAME framework that separates reasoning from execution
>> It integrates on-chain registries, tokenised agent entities, and SDKs for social and custom domains, with off-chain AI inference tied to on-chain settlements.
>> Operates primarily on Base and Ethereum L2s, it relies on ACP smart contracts, DEXs, and LLMs to handle cross-chain value flow and cognition
• Ecosystem wise, Virtuals has been performing quite well with a total ecosystem value hitting ~$2b (agents + protocol) with top performing agents in $TIBBIR and $AIXBT
• Risks include AI reasoning gaps, hallucination errors, and reliance on off-chain inference that could disrupt agent coordination, limited agent adoption, and over reliance on Base and evolving LLM capabilities

- - - - -

The AI agent interoperability landscape so far represents a similar moment that can be comped to the early internet's protocol wars. Each standard addresses different aspects of the agent economy stack, with varying maturity levels and risk profiles.

I would say the more “Production-Ready” standards (x402, MCP, Stripe ACP, A2A) have so far demonstrated real traction but face significant challenges: x402's security vulnerabilities, MCP's performance overhead and A2A's scaling issues suggest optimisation needs. Emerging standards (ERC-8004, Virtuals ACP) offer unique value propositions through trustless mechanisms and tokenisation, but face fundamental scalability (adoption and traction) and cost barriers.

My take is that successful AI agent implementations will likely require a multi-protocol approach → for example using x402 for payments, MCP for tool integration, ACP for commerce, A2A for coordination, and blockchain protocols for trust and tokenisation.

- - - - -

This piece was inspired by my smarter and more technical friends @yq_acc and @superoo7 who have put out great content on this vertical.

[wassieloyer @wassielawyer]

1/ Just realized that the Coindesk article released the full versions of (a) the contract I termed 'possibly the worst agreement I have ever seen' and (b) the agreement I drafted.

Perfect opportunity to explain legal v commercial terms, and demonstrate the role of foundations.

[Taky @20quant]

@cz_binance @AriDavidPaul @justinsuntron good to know

[Taky @20quant]

@hamptonism What you born in 1992?

[Taky @20quant]

@EvgenyGaevoy He forgot Evgeny brings humour to this table :D

[Taky @20quant]

@hamptonism For the south though.
North, feb - apr

[Taky @20quant]

@hamptonism Apr - Jun

[Taky @20quant]

@EvgenyGaevoy Does this mean 90% of company/country sucess come from luck and/or other factors?