fix: ton tx history parsing

[NeOMakinG]

Description

Fixes the TON tx parsing upserted into history, which wasn't working at all previously

Issue (if applicable)

closes #

Risk

High Risk PRs Require 2 approvals

What protocols, transaction types, wallets or contract interactions might be affected by this PR?

Testing

• Do a TON to a jettons coin swap
• Do a jettons coin swap to TON
• Notice all the TXs are upserted in the history

Engineering

Operations

• 🏁 My feature is behind a flag and doesn't require operations testing (yet)

Screenshots (if applicable)

Summary by CodeRabbit

• New Features
  • Implemented transaction history retrieval for TON blockchain
  • Added jetton (TON token) transfer tracking and support
  • Enhanced address normalization for improved transaction clarity
  • Added pagination support for efficient transaction history queries

_{✏️ Tip: You can customize this high-level summary in your review settings.}

[coderabbitai]

📝 Walkthrough

Walkthrough

This PR implements transaction history retrieval for the TON chain adapter, including batching and pagination support. It adds jetton (TON token) transfer parsing and address normalization, refactors the public parseTx method to private, and introduces new private helper functions for consolidated transfer extraction and token transfer parsing.

Changes

Cohort / File(s)	Summary
Type Definitions packages/chain-adapters/src/ton/types.ts	Added new public types TonTxMessage (with optional source, destination, value fields) and TonTx (containing account, hash, lt, now, total_fees, optional in_msg and out_msgs array).
Transaction History & Jetton Integration packages/chain-adapters/src/ton/TonChainAdapter.ts	Implemented getTxHistory() method with batching via requestQueue and pagination support (cursor, pageSize). Added parseJettonTransfers() helper to extract token transfers. Introduced parse() function to consolidate transfer extraction from in_msg/out_msgs and determine transaction status. Refactored parseTx() from public to private and expanded it to support transaction hash resolution and address book normalization. Integrated jetton transfers into transaction results.

Sequence Diagram(s)

sequenceDiagram
    actor Client
    participant getTxHistory
    participant requestQueue
    participant parseTx
    participant parseJettonTransfers
    participant addressBook

    Client->>getTxHistory: getTxHistory(input)
    activate getTxHistory
    getTxHistory->>getTxHistory: Initialize cursor & pagination
    loop Until no more results
        getTxHistory->>requestQueue: Queue fetch request
        requestQueue->>requestQueue: Fetch transactions (cursor, pageSize)
        requestQueue-->>getTxHistory: txs array
        loop For each transaction
            getTxHistory->>parseTx: parseTx(tx, pubkey)
            activate parseTx
            parseTx->>parse: parse(tx, pubkey, txid)
            activate parse
            parse->>addressBook: Normalize in_msg/out_msgs
            addressBook-->>parse: Resolved addresses
            parse-->>parseTx: Transaction with transfers
            deactivate parse
            parseTx->>parseJettonTransfers: parseJettonTransfers(txHash, pubkey)
            activate parseJettonTransfers
            parseJettonTransfers-->>parseTx: Jetton transfers
            deactivate parseJettonTransfers
            parseTx-->>getTxHistory: Combined transaction
            deactivate parseTx
        end
        getTxHistory->>getTxHistory: Update cursor
    end
    getTxHistory-->>Client: TxHistoryResponse
    deactivate getTxHistory

Loading

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~20-25 minutes

Possibly related PRs

• feat: tron parseTx() handle transfers #11449: Refactors chain adapter transaction parsing by replacing public parseTx with private parse and new private helpers to extract token/internal transfers, with concurrent updates to related types.

Suggested reviewers

• gomesalexandre

Poem

🐰 A hopping TON adapter, now quite spry,
Fetches jettons from the blockchain sky,
With history, pagination, and addresses made right,
The parser hops faster, reaching new height! 🚀

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title 'fix: ton tx history parsing' is concise and directly related to the main changes, which implement transaction history retrieval and parsing logic for TON, including jetton transfers and address resolution.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing touches

• 📝 Generate docstrings

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Post copyable unit tests in a comment
• Commit unit tests in branch auto-claude/008-the-ton-implementation-isn-t-parsing-txs-properly-

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 4

🤖 Fix all issues with AI agents

In `@packages/chain-adapters/src/ton/TonChainAdapter.ts`:
- Around line 443-447: Validate the incoming cursor before converting to an
offset: in the scope where cursor and offset are initialized (used by
fetchTxHistory), check that cursor is a valid numeric string (e.g., digits only
or Number.isFinite(Number(cursor))) and only then set offset = parseInt(cursor,
10); otherwise default offset to 0 (or handle invalid cursor explicitly). Update
the initialization around the cursor/offset variables so offset cannot become
NaN and ensure fetchTxHistory uses this validated offset.
- Around line 796-872: The catch block in the jetton transfer fetch silently
swallows errors; change the try/catch around the this.httpApiRequest call in
TonChainAdapter (the loop handling response.jetton_transfers and using
addressesMatch, toAssetId, and TransferType) to catch the error as a variable
and log a clear contextual error (include txHash and pubkey and the error/stack)
via the adapter logger (e.g., this.logger.error or existing logging facility)
before returning [] so failures are recorded for debugging.
- Around line 960-963: The parseTx method currently coerces non-string inputs to
"[object Object]" causing API failures; update parseTx to either accept only
string hashes by changing its signature to parseTx(txHash: string, pubkey:
string): Promise<Transaction> and remove the fallback conversion, or add an
explicit type guard branch for TonTx objects (e.g., detect TonTx and extract its
hash or required fields) similar to the TRON/SUI pattern; modify the function
body around parseTx and any callers to pass a string hash (or handle TonTx) and
ensure types Transaction and TonTx are used consistently.
- Around line 891-893: The code lowercases addresses when comparing
tx.in_msg.destination, tx.in_msg.source, and pubkey which corrupts user-friendly
base64 TON addresses; update the normalization used by addressesMatch (or the
caller) so only raw TON addresses (e.g., addresses that start with "0:" or are
hex/raw forms) are converted to lowercase, while base64/user-friendly addresses
are left unchanged; implement this by adding a small discriminator (raw-address
pattern vs base64 pattern) and applying .toLowerCase() only for the raw path
before comparing in addressesMatch.

[gomesalexandre]

Def. flaky but merging for the sake of progression, I'll follow-up with a few things here 🙏🏽

Spotted issues:

• Self-sends not parsed
• USDT -> TON parsing looking broken
• Tx hash looking odd with that redirect Tx url