Migrar de getSignaturesForAddress + getTransaction para getTransactionsForAddress

Migrate this codebase from the two-step Solana transaction history pattern
(getSignaturesForAddress followed by getTransaction) to the single Helius RPC
method getTransactionsForAddress.

## Background

getTransactionsForAddress is a Helius-exclusive JSON-RPC method served on
standard Helius RPC endpoints (https://mainnet.helius-rpc.com/?api-key=...).
It returns up to 1,000 full transactions per call, replacing one
getSignaturesForAddress call plus one getTransaction call per signature.
Docs: https://www.helius.dev/docs/rpc/gettransactionsforaddress.md

## Step 1: Find the old pattern

Search for:
- getSignaturesForAddress calls (via @solana/web3.js Connection, raw JSON-RPC,
  or another SDK) whose signatures are then passed to getTransaction /
  getParsedTransaction / getTransactions
- Pagination loops using `before` or `until` signature cursors
- getTokenAccountsByOwner calls used only to fetch per-token-account signature
  history

Leave standalone getTransaction calls (single-signature lookups with no
address context) unchanged.

## Step 2: Rewrite each call site

Replace the two-step flow with one raw JSON-RPC request (web3.js has no
Connection helper for this method):

```javascript
const response = await fetch(HELIUS_RPC_URL, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'getTransactionsForAddress',
    params: [
      address, // base-58 string
      {
        transactionDetails: 'full',       // or 'signatures' if only signatures were used
        maxSupportedTransactionVersion: 0, // carry over from the old getTransaction options
        encoding: 'json',                  // carry over ('json', 'jsonParsed', 'base64', 'base58')
        limit: 1000,                       // up to 1,000
        // paginationToken: '...',         // from the previous response, for page 2+
        // sortOrder: 'desc',              // 'desc' (default, newest first) or 'asc'
        // filters: { ... }                // optional, see mapping below
      }
    ]
  })
});
const { result } = await response.json();
// result.data      -> array of transactions
// result.paginationToken -> string cursor, or null when done
```

Parameter mapping:
- limit -> limit
- before: <sig> -> paginationToken (preferred) or filters: { signature: { lt: <sig> } }
- until: <sig>  -> filters: { signature: { gt: <sig> } }
- commitment -> commitment ('confirmed' or 'finalized' only; if the old code
  used 'processed', use 'confirmed')
- minContextSlot -> minContextSlot
- encoding / maxSupportedTransactionVersion (from getTransaction) -> same names,
  top level of the config object

Response shape:
- Full mode: each entry is { slot, transactionIndex, blockTime, transaction, meta }.
  transaction and meta are identical in shape to getTransaction results, so
  existing parsing code carries over. Entries are never null - remove
  null-handling that existed for missing getTransaction results.
- Signatures mode: entries match getSignaturesForAddress output
  ({ signature, slot, err, memo, blockTime, confirmationStatus }) plus
  transactionIndex.

Pagination: loop while result.paginationToken is non-null, passing it back as
paginationToken. Remove manual last-signature tracking.

If the old code fetched signatures for the wallet's token accounts too
(getTokenAccountsByOwner + per-account getSignaturesForAddress), replace all
of it with one call using filters: { tokenAccounts: 'balanceChanged' } and
delete the merge/dedupe logic.

## Step 3: Constraints and cleanup

- The endpoint must be a Helius RPC URL; other providers do not serve this
  method. Do not change endpoints for other RPC calls.
- Remove now-unused batching, throttling, and retry helpers that existed only
  for the getTransaction fan-out.
- One request covers one address; keep parallel queries for multi-address code.
- Preserve the surrounding code style and error handling conventions.

## Step 4: Verify

- Run the project's type checks and tests.
- Do NOT make any RPC calls yourself. Instead, write a standalone script (e.g.
  scripts/verify-gtfa-migration.mjs) that fetches history for one address both
  ways - the old getSignaturesForAddress + getTransaction flow and the new
  getTransactionsForAddress call with default filters - and prints whether the
  signature sets match, listing any differences. Read the RPC URL from an
  environment variable and the address from a CLI argument; never hardcode an
  API key.
- Tell the user how to run it, for example:
  HELIUS_RPC_URL="https://mainnet.helius-rpc.com/?api-key=..." \
    node scripts/verify-gtfa-migration.mjs <address>
- Summarize every call site changed and flag any you were unsure about.