Skip to main content
Skip to content
Agentic Finance

Token-2022 Transfers in 2027: Why Wallet Routes Fail

Separate missing routes, account errors and token-rule rejections. A Token-2022 case study, deployment check and local worksheet for 2027 integrations.

A coral payment tile with a small credential inset approaches a jade gate and receiving tray.
Reading options: audio, text size & sections

Decentralised News · 2027 planning series · Reviewed 22 November 2026

What Matters

A token transfer can fail because the venue cannot build a route, the transaction lacks required accounts, a token rule rejects the destination, or the submitted transaction fails for another reason. Those events require different responses. A registered agent wallet does not settle every question, and a missing quote does not establish that a wallet was excluded.

For 2027 planning, the useful task is to preserve the attempted transfer, identify where it stopped and connect the diagnosis to the version of the rules actually running. This article uses Solana Token-2022 and AgentOnly’s published design as a concrete example. DN also performed a limited, read-only deployment check and found that the current engine bytes did not match the repository’s documented October pin.

The evidence and its boundary

Reviewed 22 November 2026. Solana’s documentation establishes the transfer-hook interface. AgentOnly’s pages and public repository describe one implementation. DN inspected repository commit 576569e3dd7f54bc4c3151c4600425edc151f0b2, dated 30 October 2026, and queried public mainnet account data. These are three different evidence layers: platform specification, published implementation and observed account state.

DN did not sign, fund, simulate or execute an AgentOnly trade, rebuild its programs, or test its operating performance. The implementation discussion below describes the inspected sources; current production behavior remains unverified where the deployment linkage is unresolved. The examples and worksheet are analytical scenarios, not claims about a reader’s wallet.

Follow the transfer through four separate decisions

Start with what the application actually attempted. “Buy token A” is a user intention. A route identifies the venue and exchange path. A constructed transaction specifies instructions and accounts. Simulation evaluates that proposed transaction against a particular state. Submission and the resulting receipt establish what happened later. An interface can fail before reaching any token rule.

The distinction changes the next useful action. If no route was constructed, changing a registration record may be irrelevant. If a built transaction fails because required accounts are missing, repeatedly asking an identity service for another credential addresses a different problem. If a specific hook rejects a destination, increasing a slippage allowance does not demonstrate that the rule has been satisfied.

Observed stageEvidence to retainQuestion still open
No route or quoteVenue, mint, amount, timestamp and exact responseCould a compatible route build this transfer?
Construction failureBuilder response and unresolved account requirementsHas the instruction been assembled correctly?
Simulation resultProposed transaction, simulation context and program logsWill state or the transaction change before submission?
Submitted transactionSignature, confirmed result and actual asset movementsDid the intended economic outcome occur?

What a Token-2022 transfer hook can check

Solana’s transfer-hook documentation describes a mint extension that invokes custom program logic during transfers. Examples include recipient allowlists and custom transfer conditions. The hook interface can require additional accounts beyond the ordinary transfer accounts. A wallet interface displaying the token therefore does not establish that its transaction builder supports the complete transfer path.

The documentation also explains that the original transfer accounts become read-only within the hook call and that sender signer privileges do not automatically extend to the hook. This is an interface constraint, not a conclusion that every hooked token is safe. A token’s particular rules, other instructions and authorities still matter.

Solana’s integration guide separates detecting the extension, resolving extra accounts and simulating the constructed transaction. It warns against treating a previously resolved configuration as permanent because the hook program and account requirements can change. For an operator, that makes the observation time part of the evidence.

What “agent-only” means in the inspected example

AgentOnly’s public name is broader than the admission condition visible in its source. The pinned registry implementation accepts wallet-signed self-registration and explicitly accepts both human and agent kind values. Ecosystem attestation is a separate operation requiring the wallet and the configured attester. Self-registration alone is not a cryptographic test proving that no human controls a wallet.

The project’s homepage also describes humans setting up agents, retaining owner controls and approving exact transactions for local signing. These facts do not substantiate a category of protocols that universally reject human wallets. They support a narrower description: a system can require particular registration or provenance evidence for particular token actions.

This is where the article differs from an agent identity guide. DN’s identity-stack analysis explains identifiers, principals and authorization. The operational question here is whether the exact receiving account and transaction satisfy a token’s implemented conditions at the relevant time.

The receiving account can matter more than the wallet label

In the inspected engine source, rule 3 checks a registration flag in the destination’s holder record, subject to configured exemptions. The synchronization path can copy registry information into that record; the code also contains an authority-signed path for setting those flags. Rule 17 additionally examines an ecosystem value. These are concrete state checks, not an assessment of a model’s intelligence.

The synchronization implementation targets the owner’s associated token account for the mint. Its comments and code distinguish another token account owned by the same wallet. Consequently, a statement that “this wallet is registered” can omit the specific account record that the inspected transfer path reads. The precise relationship must be checked against the deployed implementation before relying on it.

For an integration record, retain aliases for the wallet owner and destination token account separately. Also retain the mint, network, proposed action and evidence reference. A support conversation that contains only a wallet name and a screenshot of a badge may be missing the object that the transaction actually addresses.

A failed route is not a registration verdict

AgentOnly’s published error guide distinguishes failure before transaction construction from simulation and on-chain execution. Its examples include unsupported pools, unavailable liquidity and unresolved hook accounts. Those examples explain why an external service’s “route not found” message cannot, by itself, identify a hook rejection.

Preserve the original response before interpreting it. A useful diagnosis identifies which service produced the message, whether a transaction existed and whether a program log identifies the failing instruction. The same short label can otherwise travel through an interface, an agent summary and a support ticket while losing its original meaning.

The next step should resolve the missing layer. Ask a builder about supported venue and account resolution when construction failed. Examine the relevant program and logs when simulation failed. Inspect the actual result when a transaction was submitted. None of those steps requires assuming that a new credential, a larger amount or repeated retries will help.

Read the whole configured rule stack

A transfer can satisfy a registration condition and fail another condition. AgentOnly’s AGTR token page describes a registration rule alongside a maximum balance of 500 basis points of supply, applied per receiving token account. That page is provider documentation, not DN confirmation of the mint’s current operative configuration.

The documented account-level scope has an immediate analytical consequence. A worksheet using a combined balance across every account controlled by an owner would answer a different question. Conversely, account capacity says nothing about beneficial ownership, concentration across related accounts or permission to bypass a rule. The arithmetic should describe the specified rule and preserve that scope.

Suppose an illustrative token has one million base units of supply and a 500-basis-point cap. The cap is 50,000 units. A receiving account with 48,000 units has 2,000 units of arithmetic headroom. An incoming amount of 2,001 exceeds that scenario cap by one unit. A passing registration flag would not change that calculation.

Graduation can change the question

The project’s rule registry and pinned README describe three lifecycle modes. In release, the hook retires at migration; never retains the hooked curve; house moves into the project’s house venue while retaining the mint and holder records. These are documented design paths, not interchangeable outcomes.

A record from before migration cannot automatically describe the next stage. Preserve the configured mode and evidence that a transition actually occurred. A threshold displayed on a page is not a transition receipt. Likewise, a retirement claim requires a current state check before a previous rule is treated as inactive.

The business decision can change even when the asset identifier stays the same. An agent that was allowed to prepare a transaction under one venue and rule set may need renewed review under another. A durable integration therefore tracks state transitions alongside identity rather than treating a successful onboarding event as permanent clearance.

DN’s read-only check found an unresolved version difference

DN queried getMultipleAccounts with finalized commitment on 22 November 2026 through PublicNode and Solana’s public mainnet endpoint. The responses, at slots 472,616,314 and 472,616,325, agreed on the returned account bytes for the named engine and registry program accounts, their documented ProgramData accounts and the AGTR mint. Both program accounts were executable; the mint was owned by Token-2022. This confirms those account observations, not a successful trade.

The repository’s verification file records an October 20 engine ELF length of 318,144 bytes. Its launcher pin specifies hashing ProgramData from offset 45 to the account end. DN observed a 359,149-byte account, rather than the documented 318,189 bytes, and a different tail hash.

Engine comparisonSHA-256
Repository tail pin87d31f834d31026f4492dd718f4f07d69897a8b2dd8b1257dc5c188cecc398cb
Observed ProgramData tail1be8010660caf632ba2eb35e3d10beecb6ebf7977628063dc06e547fb8113721

A follow-up read at slot 472,616,458 checked the first 318,144 bytes after the header as well. That slice also differed from the stated engine ELF hash. For the registry, the declared 92,432-byte ELF slice matched its published hash even though its account contained additional bytes. This control matters: a larger account alone would not establish that the documented executable changed.

The engine ProgramData address used was 6cU272AbbwEcr9SntbLEfSTUo2MfsdcSBcU1FsTCqMdB. The observations and hash scopes make the comparison reproducible using the official RPC interface. They do not establish why the difference exists or whether the current implementation has a defect. DN leaves the source-to-deployment linkage unresolved rather than describing the inspected code as proven current behavior.

Name the authority that can change the behavior

The token page’s statements about mint, freeze or metadata authorities do not answer who can replace a program. The pinned README separately says that the operator retains upgrade authority for the project’s programs. Solana’s program documentation explains that an upgrade authority can permit changes to a loader-v3 program and that revoking that authority makes the program immutable.

For an integration decision, record the specific authority and the object it controls. A statement such as “the authority was burned” is incomplete unless the record identifies which authority. A change to token issuance controls, a change to the rule configuration and a change to executable code can affect different assumptions.

This also gives an operations team a concrete review trigger. A new program hash should reopen the implementation record; a changed rule configuration should reopen the proposed transfer’s policy analysis. A fresh wallet credential does not perform either review.

Handle inconsistent documentation as an open question

There are narrower documentation discrepancies too. The general documentation page describes unregistered wallets as unable to buy, sell or receive gated tokens. The rule-specific registry describes rule 3 as a recipient gate and says the seller’s own exit is not the gated side. The token page describes its specific stack. Those statements have different scopes and cannot safely be compressed into “every sell is blocked.”

The pinned registry file also contains commentary describing direct registry reads while the inspected engine implements holder-record checks. DN’s interpretation follows the executable source when describing that snapshot, while retaining the deployment uncertainty above. A comment, a generated catalogue and an operating binary are different artifacts.

For the reader, the useful response is to identify the exact disputed claim and the evidence that would resolve it. A current configuration, reproducible build linkage and controlled behavioral test would answer more than another broad assurance that the protocol is “agent-only.”

Use the DN Transfer Failure Record

The local worksheet separates the observed stage, error origin, rule evidence and lifecycle state. It does not connect to a wallet or query the chain. References are aliases supplied by the reader. A simulation failure is classified as a reported hook rejection only when the reader supplies a log reference and attributes the failure to the hook; otherwise the cause remains unresolved.

The optional cap calculation uses whole base units and integer arithmetic. Its output is a capacity calculation for the entered account and supply, not an eligibility decision. Unknown rules, an unresolved deployment link or a missing route remain visible even when the arithmetic fits. When a hook is declared retired, the calculation is labeled a historical scenario.

DN Transfer Failure Record

Change the illustrative assumptions below. This worksheet runs locally in your browser. It records your declarations; it does not verify evidence, connect to accounts, submit instructions or grant approval.

Route unavailable; eligibility unresolved

Observed stageno route
Deployment relationshipunknown
Cap in base units50000
Headroom before transfer2000
Projected account balance50000
Capacity arithmeticWithin entered cap
  • Identify the venue and builder response. No constructed transaction means this result does not establish a hook veto.
  • Current rule and deployment evidence is unresolved. A claimed match without an evidence reference is incomplete.
  • Receiving-account eligibility is unresolved. Neither a route response nor cap arithmetic supplies that evidence.
  • Cap = floor(supply × basis points ÷ 10,000). This is per entered token account, not an aggregate wallet or beneficial-owner limit.
  • Capacity arithmetic does not establish active rules, recipient eligibility, a usable route, owner approval or a successful transfer.
Attempt: Example A Stage evidence: router-response-A Policy/deployment evidence: missing Receiving account evidence: destination-account-A Scope: reader-declared evidence and synthetic arithmetic. No network request, wallet connection, signing, approval or transaction execution.

The initial numbers are synthetic. Unknown evidence remains unresolved. Downloads contain the values you enter; use aliases and avoid private or identifying information.

Two records that lead to different next steps

Scenario A: registration evidence, no quote. An operator records a registration reference and an account balance below its illustrative cap. The external route service returns no quote. There is no constructed transaction and no hook log. The appropriate finding is a route problem with token eligibility still unresolved. Counting the cap result as approval would move a conclusion across evidence layers.

Scenario B: a named simulation rejection. A different operator retains the proposed transaction and a simulation log naming the hook’s registration error. The destination token account in that transaction differs from the account in the operator’s registration record. That discrepancy is a concrete investigation target. It does not authorize moving funds, changing destinations or asserting that synchronization will solve every other rule.

Both records can be useful without assigning a universal readiness score. They tell the operator what has been observed, what inference is justified and which unresolved fact prevents the next conclusion. That is the practical value of preserving the failure stage.

Methodology and update conditions

DN compared official Solana documentation, provider pages, a pinned repository snapshot and limited public account reads. The code inspection was targeted at registration, holder synchronization, recipient checks and documented lifecycle behavior. It was not a security audit. The two RPC services supplied separate observations of the same chain state; their agreement does not create two independent behavioral tests.

Revisit the conclusions when the implementation changes, the provider reconciles its deployment pin, a token changes lifecycle stage or a controlled test establishes a specific transfer outcome. Keep the original record so that a later successful transfer does not erase an earlier construction failure. For the broader principal and compliance questions, see DN’s principal, permission and payment analysis.

Sources and evidence register

Primary sources reviewed on 22 November 2026. The article distinguishes documented facts, DN analysis and synthetic examples. Recheck changeable rules and configurations before acting.

  1. Solana: Transfer Hook — Platform interface, transfer invocation, extra accounts and limits on privileges.
  2. Solana: Transfer Hook Integration Guide — Detection, account resolution, simulation and configuration freshness.
  3. AgentOnly: Project homepage — Provider statements about owner controls and exact transaction approval; no universal non-human proof.
  4. AgentOnly: Registry implementation, pinned commit — Inspected Register and parse_kind paths accept human and agent kind values; attestation is separate. Comments are not proof of current deployment behavior.
  5. AgentOnly: Engine implementation, pinned commit — Targeted inspection of SyncRegistered, module_agent_only and module_ecosystem_gate. Current source-to-deployment linkage remains unresolved.
  6. AgentOnly: Errors and failure layers — Provider taxonomy separates construction, simulation and execution. Read as documentation, not instructions executed by DN.
  7. AgentOnly: AGTR token page — Provider-described token stack, per-token-account cap, recipient rules and release lifecycle. DN did not test token behavior.
  8. AgentOnly: Rule registry — Rule-specific recipient scope and documented lifecycle treatment; catalogue maturity labels are provider claims.
  9. AgentOnly: README, pinned commit — Published lifecycle modes, retained program upgrade authority and deployment versus exercise distinctions.
  10. AgentOnly: Verification record, pinned commit — October 20 program addresses, ELF lengths and hashes, compared with DN account observations.
  11. AgentOnly: Engine pin, pinned commit — Exact tail-hash scope and October 20 engine pin; differs from the observed November 22 account bytes.
  12. Solana: getMultipleAccounts — Method used for DN read-only finalized account observations. Raw responses are retained in the accompanying source audit.
  13. Solana: Programs — Upgradeable loader-v3 programs and the distinction between executable code and mutable state.
  14. AgentOnly: General documentation — Compared with narrower rule and token descriptions; conflicting scope is preserved as unresolved.

Frequently asked questions

Does an agent-only token prove that human wallets cannot use it?

No. In the inspected AgentOnly registry source, self-registration accepts both human and agent kind values. A token rule can require registration or an attestation without proving that no human controls the wallet.

Does route not found mean the transfer hook rejected my wallet?

No. A route can fail before any transaction exists. Retain the builder response and distinguish construction, simulation and execution before attributing the failure to a rule.

Can registration be valid while a transfer still fails?

Yes. The relevant destination account, other configured rules, required accounts, current deployment and venue support remain separate questions. Registration alone does not establish a successful transfer.

Does graduation always remove the token rules?

No. The provider documents release, never and house modes with different behavior. Verify the configured mode and actual transition before treating a previous rule as retired.

Did DN independently test AgentOnly trading?

No. DN inspected published sources and read public finalized account data. It observed an engine hash difference from the repository pin, but did not rebuild, simulate, sign or execute a trade.

What does a passing balance-cap result prove?

Only that the entered balance plus incoming base units fits the entered scenario cap. It does not establish active policy, recipient eligibility, route availability, owner approval or execution.

DN research note: This article is original editorial analysis supported by the linked sources. Calculations and example cases are illustrative unless explicitly described otherwise. The worksheet is a planning aid; it does not carry out the actions it describes.

Get the most talked about stories directly in your inbox

Join the Decentralised News briefing for independent crypto, DeFi and AI analysis. No spam, unsubscribe anytime.