crypto-aio 0.0.3 → 0.1.0

package/dist/adapters/tron/proofs.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Proofs, the block source and TronGrid history.
+ *
+ * Proofs: every read is a `proof` quorum
+ * read, and each fact is attested at its own height, so no endpoint proposes a height:
+ * - "my solidified block's timestamp is at or past the expiration" is a monotone predicate
+ *   quorum key on the latest solidified block; honest endpoints disagree only in the moment
+ *   it becomes true on one of them, which decides nothing;
+ * - a block at a fixed height is read from the solidity node, which serves it only once it
+ *   is solidified there, keyed on its consensus facts;
+ * - `finalizedHead` is the one unanchored read: one endpoint's view, trailed by
+ *   `PEER_SKEW` blocks, then attested at that height.
+ * A stale or lagging answer is a retryable `PROVIDER_INCONSISTENT` or `PROVIDER_UNAVAILABLE`
+ * and decides nothing.
+ *
+ * Which blocks can hold a transaction (java-tron GreatVoyage-v4.8.2.2 `d5c3d1d1`:
+ * `Manager.processBlock` runs `processTransaction`, so `validateTapos` and `validateCommon`,
+ * for each transaction, and only then records the block in the recent-block store and as
+ * the head):
+ * - expiry: a transaction is invalid in a block whose parent's timestamp is at or past
+ *   its expiration, and block timestamps strictly increase, so no block after the first one
+ *   at or past the expiration can hold it;
+ * - TaPoS: only a block above the reference block, and at most `TAPOS_WINDOW` above it, can
+ *   hold it.
+ *
+ * "Not included": the solidity index (and TronGrid behind a load balancer) can lag, so an
+ * empty index answer is never taken as absence: an expired verdict for a transfer the
+ * index missed would let `rebuild` pay twice.
+ * `includedFinal` answers `included: false` only once expiry is attested and a scan of every
+ * block that could hold the transaction shows it absent, from the attested first block at or
+ * past the SIGNED expiration (`expiresAtMs`, which `assemble` binds to the signed bytes) down
+ * to just above the reference block. The floor is never a time derived from the expiration:
+ * the build-time head and the local clock are claims, so the expiration can sit any distance
+ * after the reference.
+ * - The ordering (`TronExpiryOrdering`) carries the reference height the build-time head
+ *   claimed (`lastValidHeight − TAPOS_WINDOW`) and the signed `ref_block_hash`. Only the
+ *   height's low 16 bits are signed (`ref_block_bytes`), so the height is trusted only when
+ *   the attested solidified block there carries the signed hash: then the scan runs from the
+ *   top down to it.
+ * - Otherwise (another block there, or a height at or above the top) the proof searches the
+ *   heights TaPoS can match: every block up to the top checks the reference against the latest
+ *   block at or below its parent with the signed low 16 bits, and its parent is at most 24 h
+ *   before the expiration (`MAXIMUM_TIME_UNTIL_EXPIRATION`). So the attested blocks at those
+ *   heights, from one TaPoS window below that 24 h mark up to the top, are the only possible
+ *   references. None carries the signed hash: no block can hold the transaction. One does:
+ *   the blocks in its TaPoS window (and not before the 24 h mark) are scanned.
+ * - Either way, a block whose parent is more than 24 h before the expiration cannot hold the
+ *   transaction, so no scan goes below the first block at or past that mark.
+ * - A missing or malformed stored hash decides nothing.
+ * Each scanned block is read by hash under the quorum, its parent hash names the next, and the
+ * walk must end on the attested block below the window. A scanned block that holds the
+ * transaction while the index says nothing decides nothing.
+ *
+ * Read cost, each read a quorum read: the reference check is one; a scan is one per block in
+ * the window (about 20 for a 60 s expiration). A reference older than a day (a build head that
+ * named an old block), or the search below, adds a gallop and binary search for the block 24 h
+ * before the expiration (a few reads, logarithmic in missed slots). The search, only when the
+ * stored height is not the reference, adds one read per candidate height (two or three). A
+ * scan never covers more than the blocks from that 24 h mark to the first block at or past the
+ * expiration: at most a day of blocks (28,800 at one per 3-second slot, fewer when slots are
+ * missed), and never more than one TaPoS window (65,536).
+ */
+import type { AddressHistorySource, BlockSource, DriverTransaction, ProofSource } from '../../core/driver/types';
+import type { Transport } from '../../core/transport/types';
+import type { TronContext } from './reader';
+export declare function createTronProofs(ctx: TronContext): ProofSource;
+export declare function createTronBlocks(ctx: TronContext): BlockSource;
+/**
+ * TronGrid history, each entry re-read from the full node and decoded like any
+ * transaction; confirmed (solidified) entries only (`historyPage`). Phase `t` is
+ * `/transactions`: the account's own transactions, TRX sent to it and, for a contract
+ * account, other accounts' calls to it. Phase `x` is `/transactions/trc20`: every TRC-20
+ * transfer from or to it (a spender's `transferFrom` out of it included), less the account's
+ * own calls, which phase `t` listed. A TRC-20 transfer a wallet only received is in phase `x`
+ * alone (TronGrid, read-only on Nile, 2026-09-28), but a call to a contract account that moves
+ * its own tokens comes in both phases, so callers dedupe on `transfer.id`.
+ * Paging follows the raw page's fingerprint, never how many items survive the filter, and
+ * an entry the node cannot serve yet decides nothing: dropping it would skip it for good.
+ */
+export declare function createTronHistory(ctx: TronContext, indexer: Transport, getTransaction: (id: string) => Promise<DriverTransaction | null>): AddressHistorySource;

package/dist/adapters/tron/proofs.js

@@ -0,0 +1,370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTronProofs = createTronProofs;
+exports.createTronBlocks = createTronBlocks;
+exports.createTronHistory = createTronHistory;
+const error_1 = require("../../core/errors/error");
+const address_1 = require("./address");
+const decode_1 = require("./decode");
+const http_1 = require("./http");
+const network_1 = require("./network");
+function undecided() {
+    return new error_1.ProviderError('PROVIDER_UNAVAILABLE', 'finalized state cannot decide this yet');
+}
+/** Attested answers that the chain's own rules make impossible together: decides nothing. */
+function contradiction(what) {
+    return new error_1.ProviderError('PROVIDER_INCONSISTENT', `${what}, which decides nothing`, {
+        retryable: true,
+    });
+}
+const SLOT_MS = 3_000;
+/**
+ * How far `finalizedHead` trails one endpoint's solidified head: up to 6 s behind, and no
+ * verdict reads it.
+ */
+const PEER_SKEW = 2n;
+/** java-tron's block heights are `long`s. */
+const INT64_MAX = 2n ** 63n - 1n;
+const TX_ID = /^[0-9a-f]{64}$/;
+/** A signed `ref_block_hash`: 8 bytes, lower-case hex, as the builder stores it. */
+const REF_HASH = /^[0-9a-f]{16}$/;
+/**
+ * java-tron's `MAXIMUM_TIME_UNTIL_EXPIRATION` (`Constant.java`): `validateCommon` refuses an
+ * expiration more than 24 h after the parent block's time.
+ */
+const MAX_LIFETIME_MS = 86_400_000;
+/** The timestamp of a solidified-block answer, or -1 when it is not one (never agrees). */
+function solidTimestamp(answer) {
+    const raw = answer
+        ?.block_header?.raw_data;
+    return typeof raw?.timestamp === 'number' ? raw.timestamp : -1;
+}
+/**
+ * Where an Attempt can be, from its `TronExpiryOrdering`; null when a field is missing or
+ * out of range, which decides nothing.
+ */
+function attemptBounds(ordering) {
+    if (ordering.kind !== 'expiry')
+        return null;
+    const { expiresAtMs, lastValidHeight, refBlockHash } = ordering;
+    if (!Number.isSafeInteger(expiresAtMs) ||
+        typeof lastValidHeight !== 'bigint' ||
+        lastValidHeight < network_1.TAPOS_WINDOW ||
+        lastValidHeight > INT64_MAX ||
+        typeof refBlockHash !== 'string' ||
+        !REF_HASH.test(refBlockHash)) {
+        return null;
+    }
+    return {
+        expiration: expiresAtMs,
+        reference: lastValidHeight - network_1.TAPOS_WINDOW,
+        refBlockHash,
+    };
+}
+/** Bytes 8..16 of a block id: what a transaction's `ref_block_hash` names. */
+const hashBytes = (block) => block.id.slice(16, 32);
+/** Scanned blocks kept per driver: immutable chain data, so a retry is cheap. */
+const SCAN_CACHE_SIZE = 1_024;
+function createTronProofs(ctx) {
+    const { api } = ctx;
+    // Only quorum-agreed blocks below an attested solidified block, keyed by hash: final.
+    const scanned = new Map();
+    /** The block `hash`, expected at `height`; cached only once its height checks out. */
+    async function finalBlockByHash(hash, height) {
+        const cached = scanned.get(hash);
+        if (cached)
+            return cached;
+        const block = await api.rpcBlock(hash, http_1.PROOF);
+        if (block && block.number === height) {
+            if (scanned.size >= SCAN_CACHE_SIZE) {
+                scanned.delete(scanned.keys().next().value);
+            }
+            scanned.set(hash, block);
+        }
+        return block;
+    }
+    /** A block at a fixed height, attested as solidified on every quorum endpoint. */
+    async function solidHeader(height) {
+        const header = await api.block('solid', height, http_1.PROOF);
+        if (!header)
+            throw undecided();
+        return header;
+    }
+    /**
+     * The latest solidified block when every quorum endpoint's solidified block is at or past
+     * `expiration` (a monotone predicate), else null.
+     */
+    async function passedExpiry(expiration) {
+        const head = (await api.block('solid', undefined, {
+            ...http_1.PROOF,
+            quorumKey: (answer) => solidTimestamp(answer) >= expiration,
+        }));
+        return head.timestamp >= expiration ? head : null;
+    }
+    /**
+     * The first solidified block at or past `time`, at or below `hi` (an attested block at or
+     * past it). Block timestamps strictly increase, so "at or past `time`" is monotone in the
+     * height: a gallop down from the slot estimate, then a binary search. Every probe is
+     * an attested fixed-height read at or below `hi`, which every quorum endpoint has
+     * solidified, so none can stall; the slot spacing only picks the first probe.
+     */
+    async function firstAtOrAfter(time, hi) {
+        let high = hi;
+        let low;
+        let step = BigInt(Math.max(1, Math.floor((hi.timestamp - time) / SLOT_MS)));
+        while (low === undefined) {
+            if (high.number === 0n)
+                return high;
+            const probe = await solidHeader(high.number > step ? high.number - step : 0n);
+            if (probe.timestamp < time) {
+                low = probe;
+            }
+            else {
+                high = probe;
+                step *= 2n;
+            }
+        }
+        while (high.number - low.number > 1n) {
+            const mid = await solidHeader((low.number + high.number) / 2n);
+            if (mid.timestamp < time)
+                low = mid;
+            else
+                high = mid;
+        }
+        return high;
+    }
+    /**
+     * The first solidified block at or past `expiration`, or null while the quorum has not
+     * solidified past it. Only the predicate is attested: the latest block's height and time
+     * are one endpoint's word, so a block trailed by the peer skew is attested at its own height
+     * (a freshest endpoint then stalls nothing), and the search runs at or below it
+     * or, within the skew, up to the first block at the expiration, which every endpoint has
+     * solidified (bounded, whatever the endpoint claimed).
+     */
+    async function expiryBlock(expiration) {
+        const seen = await passedExpiry(expiration);
+        if (!seen)
+            return null;
+        let top = await solidHeader(seen.number > PEER_SKEW ? seen.number - PEER_SKEW : 0n);
+        if (top.timestamp >= expiration)
+            return firstAtOrAfter(expiration, top);
+        while (top.timestamp < expiration) {
+            if (top.number >= seen.number)
+                throw undecided();
+            top = await solidHeader(top.number + 1n);
+        }
+        return top;
+    }
+    /**
+     * No block above the attested `floor`, at or below `last` and `top`, holds `id`: walked by
+     * parent hash from the upper end, which must arrive at `floor`. Throws when anything cannot
+     * be decided. Every height read is below `top`, which every quorum endpoint has solidified.
+     */
+    async function absentAbove(id, floor, top, last) {
+        const end = last < top.number ? last : top.number;
+        if (end <= floor.number)
+            return;
+        const start = end === top.number ? top : await solidHeader(end);
+        let hash = start.id;
+        for (let height = start.number; height > floor.number; height -= 1n) {
+            const block = await finalBlockByHash(hash, height);
+            // Missing, or not the block the parent chain leads to: an endpoint is behind or lying.
+            if (!block || block.number !== height)
+                throw undecided();
+            // In a solidified block, yet the index said nothing: it lags. Decide later.
+            if (block.transactions.includes(id))
+                throw undecided();
+            hash = block.parentHash;
+        }
+        // The walk is bound at both ends: it must arrive at the attested block below the window.
+        if (hash !== floor.id) {
+            throw contradiction('the scanned blocks do not lead to the reference block');
+        }
+    }
+    /**
+     * Absence proven by scan; throws when anything cannot be decided. `top`
+     * is the attested first block at or past the expiration: no block above it can hold `id`.
+     */
+    async function absent(id, bounds, top) {
+        const { reference, refBlockHash } = bounds;
+        /** The 24 h mark: only a block whose parent is at or after it can hold `id`. */
+        const dayMark = bounds.expiration - MAX_LIFETIME_MS;
+        // The stored height is the build-time head's claim: it bounds the scan only when the
+        // attested block there carries the signed hash bytes.
+        if (reference < top.number) {
+            const named = await solidHeader(reference);
+            if (hashBytes(named) === refBlockHash) {
+                // A reference older than a day (a build head that named an old block) is
+                // scanned only from the 24 h mark, as the search below does, never its whole window.
+                const floor = named.timestamp < dayMark ? await firstAtOrAfter(dayMark, top) : named;
+                await absentAbove(id, floor, top, reference + network_1.TAPOS_WINDOW);
+                return;
+            }
+        }
+        // Otherwise, the heights TaPoS can match: the signed low 16 bits, below the top, from one
+        // TaPoS window below the first block within 24 h of the expiration (a block's parent is at
+        // or after it). Every block up to the top checks the reference against one of them.
+        const earliest = await firstAtOrAfter(dayMark, top);
+        const low16 = reference % network_1.TAPOS_WINDOW;
+        const from = earliest.number + 1n > network_1.TAPOS_WINDOW ? earliest.number + 1n - network_1.TAPOS_WINDOW : 0n;
+        let height = from + ((low16 - (from % network_1.TAPOS_WINDOW) + network_1.TAPOS_WINDOW) % network_1.TAPOS_WINDOW);
+        for (; height < top.number; height += network_1.TAPOS_WINDOW) {
+            const candidate = await solidHeader(height);
+            if (hashBytes(candidate) !== refBlockHash)
+                continue;
+            // Its TaPoS window, less the blocks whose parent is more than 24 h before the expiration.
+            const floor = candidate.number >= earliest.number ? candidate : earliest;
+            await absentAbove(id, floor, top, candidate.number + network_1.TAPOS_WINDOW);
+        }
+    }
+    return {
+        async finalizedHead() {
+            // The unanchored exception: one endpoint's view, trailed by the peer skew, attested.
+            const seen = (await api.block('solid', undefined, http_1.MONITOR));
+            const head = await solidHeader(seen.number > PEER_SKEW ? seen.number - PEER_SKEW : 0n);
+            return { height: head.number, hash: head.id, timestamp: head.timestamp };
+        },
+        async includedFinal(ref, ordering) {
+            // Bounded before any work; our own Attempt's ref is always a txID.
+            if (typeof ref.id !== 'string' || ref.id.length !== 64)
+                throw undecided();
+            const id = ref.id.toLowerCase();
+            if (!TX_ID.test(id))
+                throw undecided();
+            const info = await api.transactionInfo('solid', id, http_1.PROOF);
+            if (info) {
+                const [header, tx] = await Promise.all([
+                    api.block('solid', info.blockNumber, http_1.PROOF),
+                    api.transaction('solid', id, http_1.PROOF),
+                ]);
+                if (!header || !tx)
+                    throw undecided();
+                // java-tron writes the block's time into each receipt (`blockTimeStamp`): a receipt
+                // dated otherwise is not from the solidified block at its height.
+                if (info.blockTimestamp !== header.timestamp) {
+                    throw contradiction('a receipt does not match its solidified block');
+                }
+                // `verdictOf` pairs the receipt with the transaction by id, reads the verdict
+                // fields strictly and wants evidence that value moved; a contradiction decides
+                // nothing.
+                const verdict = (0, decode_1.verdictOf)(ctx.codec, tx, info);
+                return {
+                    included: true,
+                    success: verdict.success,
+                    blockHeight: info.blockNumber,
+                    blockHash: header.id,
+                    txHash: id,
+                    ...(verdict.reason !== undefined ? { reason: verdict.reason } : {}),
+                };
+            }
+            const bounds = attemptBounds(ordering);
+            if (!bounds)
+                throw undecided();
+            const top = await expiryBlock(bounds.expiration);
+            if (!top)
+                throw undecided();
+            await absent(id, bounds, top);
+            return { included: false };
+        },
+        async slotConsumed() {
+            // Tron has no nonce or sequence: expiry is the only way an Attempt dies.
+            return false;
+        },
+        async expired(ordering) {
+            if (ordering.kind !== 'expiry' || !Number.isSafeInteger(ordering.expiresAtMs)) {
+                return false;
+            }
+            return (await expiryBlock(ordering.expiresAtMs)) !== null;
+        },
+        async blockHash(height, level) {
+            if (height < 0n || height > INT64_MAX)
+                return null;
+            const header = await api.block(level === 'finalized' ? 'solid' : 'full', height, http_1.PROOF);
+            return header?.id ?? null;
+        },
+    };
+}
+function createTronBlocks(ctx) {
+    return {
+        async header(height) {
+            const header = await ctx.api.block('full', height, http_1.MONITOR);
+            return header
+                ? {
+                    height: header.number,
+                    hash: header.id,
+                    parentHash: header.parentId,
+                    timestamp: header.timestamp,
+                }
+                : null;
+        },
+        async transactions(block, filter) {
+            // Genesis holds only the chain's initial allocations, which are not reported,
+            // and java-tron answers `{}` for its receipts, which a scanner would retry for ever.
+            if (block.height === 0n)
+                return [];
+            const read = await ctx.api.blockWithTransactions(block.height, http_1.MONITOR);
+            if (!read || read.header.id !== block.hash) {
+                throw new error_1.ProviderError('PROVIDER_INCONSISTENT', `block ${block.height} changed while scanning`, { retryable: true });
+            }
+            // Receipts pair with transactions by id, never by position.
+            const infos = new Map(read.infos.map((info) => [info.id, info]));
+            const txs = read.transactions.map((tx) => {
+                const info = infos.get(tx.id);
+                if (!info) {
+                    throw new error_1.ProviderError('PROVIDER_UNAVAILABLE', 'a scanned block lacks a receipt');
+                }
+                return (0, decode_1.decodeTransaction)(ctx.codec, tx, info, block.hash);
+            });
+            if (!filter?.addresses?.length)
+                return txs;
+            const wanted = new Set(filter.addresses.map((a) => (0, address_1.toBase58Address)(a)));
+            return txs.filter((tx) => wanted.has(String(tx.details.owner)) ||
+                tx.transfers.some((t) => wanted.has(t.to) || t.from.some((f) => wanted.has(f))));
+        },
+    };
+}
+const CURSOR = /^([tx]):(.*)$/;
+/** The largest page TronGrid serves. */
+const MAX_PAGE = 200;
+/**
+ * TronGrid history, each entry re-read from the full node and decoded like any
+ * transaction; confirmed (solidified) entries only (`historyPage`). Phase `t` is
+ * `/transactions`: the account's own transactions, TRX sent to it and, for a contract
+ * account, other accounts' calls to it. Phase `x` is `/transactions/trc20`: every TRC-20
+ * transfer from or to it (a spender's `transferFrom` out of it included), less the account's
+ * own calls, which phase `t` listed. A TRC-20 transfer a wallet only received is in phase `x`
+ * alone (TronGrid, read-only on Nile, 2026-09-28), but a call to a contract account that moves
+ * its own tokens comes in both phases, so callers dedupe on `transfer.id`.
+ * Paging follows the raw page's fingerprint, never how many items survive the filter, and
+ * an entry the node cannot serve yet decides nothing: dropping it would skip it for good.
+ */
+function createTronHistory(ctx, indexer, getTransaction) {
+    return {
+        async list(address, options) {
+            const match = CURSOR.exec(options.cursor ?? 't:');
+            if (!match)
+                throw new error_1.ConfigError('CONFIG_INVALID', 'not a Tron history cursor');
+            const phase = match[1];
+            const fingerprint = match[2];
+            const owner = (0, address_1.toBase58Address)(address);
+            const page = await (0, http_1.historyPage)(indexer, owner, phase === 't' ? 'transactions' : 'trc20', {
+                limit: Math.min(Math.max(Math.trunc(options.limit) || 1, 1), MAX_PAGE),
+                ...(fingerprint ? { fingerprint } : {}),
+            }, http_1.READ);
+            const items = [];
+            for (const id of page.ids) {
+                const tx = await getTransaction(id);
+                // The index lists it as confirmed: a node that serves nothing, or only its pool
+                // copy, is behind; listing that copy would move the cursor past it for good.
+                if (!tx || tx.observation.seen !== 'block')
+                    throw (0, http_1.notServable)();
+                // Phase x skips the account's own calls: phase t listed them.
+                if (!(phase === 'x' && tx.details.owner === owner))
+                    items.push(tx);
+            }
+            const next = page.next ? `${phase}:${page.next}` : phase === 't' ? 'x:' : undefined;
+            return { items, ...(next !== undefined ? { next } : {}) };
+        },
+    };
+}
+//# sourceMappingURL=proofs.js.map

package/dist/adapters/tron/proofs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proofs.js","sourceRoot":"","sources":["../../../src/adapters/tron/proofs.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Proofs, the block source and TronGrid history.\n *\n * Proofs: every read is a `proof` quorum\n * read, and each fact is attested at its own height, so no endpoint proposes a height:\n * - \"my solidified block's timestamp is at or past the expiration\" is a monotone predicate\n *   quorum key on the latest solidified block; honest endpoints disagree only in the moment\n *   it becomes true on one of them, which decides nothing;\n * - a block at a fixed height is read from the solidity node, which serves it only once it\n *   is solidified there, keyed on its consensus facts;\n * - `finalizedHead` is the one unanchored read: one endpoint's view, trailed by\n *   `PEER_SKEW` blocks, then attested at that height.\n * A stale or lagging answer is a retryable `PROVIDER_INCONSISTENT` or `PROVIDER_UNAVAILABLE`\n * and decides nothing.\n *\n * Which blocks can hold a transaction (java-tron GreatVoyage-v4.8.2.2 `d5c3d1d1`:\n * `Manager.processBlock` runs `processTransaction`, so `validateTapos` and `validateCommon`,\n * for each transaction, and only then records the block in the recent-block store and as\n * the head):\n * - expiry: a transaction is invalid in a block whose parent's timestamp is at or past\n *   its expiration, and block timestamps strictly increase, so no block after the first one\n *   at or past the expiration can hold it;\n * - TaPoS: only a block above the reference block, and at most `TAPOS_WINDOW` above it, can\n *   hold it.\n *\n * \"Not included\": the solidity index (and TronGrid behind a load balancer) can lag, so an\n * empty index answer is never taken as absence: an expired verdict for a transfer the\n * index missed would let `rebuild` pay twice.\n * `includedFinal` answers `included: false` only once expiry is attested and a scan of every\n * block that could hold the transaction shows it absent, from the attested first block at or\n * past the SIGNED expiration (`expiresAtMs`, which `assemble` binds to the signed bytes) down\n * to just above the reference block. The floor is never a time derived from the expiration:\n * the build-time head and the local clock are claims, so the expiration can sit any distance\n * after the reference.\n * - The ordering (`TronExpiryOrdering`) carries the reference height the build-time head\n *   claimed (`lastValidHeight − TAPOS_WINDOW`) and the signed `ref_block_hash`. Only the\n *   height's low 16 bits are signed (`ref_block_bytes`), so the height is trusted only when\n *   the attested solidified block there carries the signed hash: then the scan runs from the\n *   top down to it.\n * - Otherwise (another block there, or a height at or above the top) the proof searches the\n *   heights TaPoS can match: every block up to the top checks the reference against the latest\n *   block at or below its parent with the signed low 16 bits, and its parent is at most 24 h\n *   before the expiration (`MAXIMUM_TIME_UNTIL_EXPIRATION`). So the attested blocks at those\n *   heights, from one TaPoS window below that 24 h mark up to the top, are the only possible\n *   references. None carries the signed hash: no block can hold the transaction. One does:\n *   the blocks in its TaPoS window (and not before the 24 h mark) are scanned.\n * - Either way, a block whose parent is more than 24 h before the expiration cannot hold the\n *   transaction, so no scan goes below the first block at or past that mark.\n * - A missing or malformed stored hash decides nothing.\n * Each scanned block is read by hash under the quorum, its parent hash names the next, and the\n * walk must end on the attested block below the window. A scanned block that holds the\n * transaction while the index says nothing decides nothing.\n *\n * Read cost, each read a quorum read: the reference check is one; a scan is one per block in\n * the window (about 20 for a 60 s expiration). A reference older than a day (a build head that\n * named an old block), or the search below, adds a gallop and binary search for the block 24 h\n * before the expiration (a few reads, logarithmic in missed slots). The search, only when the\n * stored height is not the reference, adds one read per candidate height (two or three). A\n * scan never covers more than the blocks from that 24 h mark to the first block at or past the\n * expiration: at most a day of blocks (28,800 at one per 3-second slot, fewer when slots are\n * missed), and never more than one TaPoS window (65,536).\n */\nimport type {\n  AddressHistorySource,\n  BlockSource,\n  DriverTransaction,\n  ProofSource,\n} from '../../core/driver/types';\nimport { ConfigError, ProviderError } from '../../core/errors/error';\nimport type { OrderingData } from '../../core/model/ordering';\nimport type { Transport } from '../../core/transport/types';\nimport { toBase58Address } from './address';\nimport { decodeTransaction, verdictOf } from './decode';\nimport {\n  MONITOR,\n  PROOF,\n  READ,\n  historyPage,\n  notServable,\n  type RpcBlock,\n  type TronBlockHeader,\n} from './http';\nimport { TAPOS_WINDOW } from './network';\nimport type { TronContext } from './reader';\nimport type { TronExpiryOrdering } from './types';\n\nfunction undecided(): ProviderError {\n  return new ProviderError(\n    'PROVIDER_UNAVAILABLE',\n    'finalized state cannot decide this yet',\n  );\n}\n\n/** Attested answers that the chain's own rules make impossible together: decides nothing. */\nfunction contradiction(what: string): ProviderError {\n  return new ProviderError('PROVIDER_INCONSISTENT', `${what}, which decides nothing`, {\n    retryable: true,\n  });\n}\n\nconst SLOT_MS = 3_000;\n/**\n * How far `finalizedHead` trails one endpoint's solidified head: up to 6 s behind, and no\n * verdict reads it.\n */\nconst PEER_SKEW = 2n;\n/** java-tron's block heights are `long`s. */\nconst INT64_MAX = 2n ** 63n - 1n;\nconst TX_ID = /^[0-9a-f]{64}$/;\n/** A signed `ref_block_hash`: 8 bytes, lower-case hex, as the builder stores it. */\nconst REF_HASH = /^[0-9a-f]{16}$/;\n/**\n * java-tron's `MAXIMUM_TIME_UNTIL_EXPIRATION` (`Constant.java`): `validateCommon` refuses an\n * expiration more than 24 h after the parent block's time.\n */\nconst MAX_LIFETIME_MS = 86_400_000;\n\n/** The timestamp of a solidified-block answer, or -1 when it is not one (never agrees). */\nfunction solidTimestamp(answer: unknown): number {\n  const raw = (answer as { block_header?: { raw_data?: { timestamp?: unknown } } } | null)\n    ?.block_header?.raw_data;\n  return typeof raw?.timestamp === 'number' ? raw.timestamp : -1;\n}\n\ninterface Bounds {\n  /** The signed expiration. */\n  readonly expiration: number;\n  /** The reference height the build-time head claimed: only its low 16 bits are signed. */\n  readonly reference: bigint;\n  /** The signed `ref_block_hash`. */\n  readonly refBlockHash: string;\n}\n\n/**\n * Where an Attempt can be, from its `TronExpiryOrdering`; null when a field is missing or\n * out of range, which decides nothing.\n */\nfunction attemptBounds(ordering: OrderingData): Bounds | null {\n  if (ordering.kind !== 'expiry') return null;\n  const { expiresAtMs, lastValidHeight, refBlockHash } =\n    ordering as Partial<TronExpiryOrdering>;\n  if (\n    !Number.isSafeInteger(expiresAtMs) ||\n    typeof lastValidHeight !== 'bigint' ||\n    lastValidHeight < TAPOS_WINDOW ||\n    lastValidHeight > INT64_MAX ||\n    typeof refBlockHash !== 'string' ||\n    !REF_HASH.test(refBlockHash)\n  ) {\n    return null;\n  }\n  return {\n    expiration: expiresAtMs as number,\n    reference: lastValidHeight - TAPOS_WINDOW,\n    refBlockHash,\n  };\n}\n\n/** Bytes 8..16 of a block id: what a transaction's `ref_block_hash` names. */\nconst hashBytes = (block: TronBlockHeader): string => block.id.slice(16, 32);\n\n/** Scanned blocks kept per driver: immutable chain data, so a retry is cheap. */\nconst SCAN_CACHE_SIZE = 1_024;\n\nexport function createTronProofs(ctx: TronContext): ProofSource {\n  const { api } = ctx;\n  // Only quorum-agreed blocks below an attested solidified block, keyed by hash: final.\n  const scanned = new Map<string, RpcBlock>();\n\n  /** The block `hash`, expected at `height`; cached only once its height checks out. */\n  async function finalBlockByHash(\n    hash: string,\n    height: bigint,\n  ): Promise<RpcBlock | null> {\n    const cached = scanned.get(hash);\n    if (cached) return cached;\n    const block = await api.rpcBlock(hash, PROOF);\n    if (block && block.number === height) {\n      if (scanned.size >= SCAN_CACHE_SIZE) {\n        scanned.delete(scanned.keys().next().value as string);\n      }\n      scanned.set(hash, block);\n    }\n    return block;\n  }\n\n  /** A block at a fixed height, attested as solidified on every quorum endpoint. */\n  async function solidHeader(height: bigint): Promise<TronBlockHeader> {\n    const header = await api.block('solid', height, PROOF);\n    if (!header) throw undecided();\n    return header;\n  }\n\n  /**\n   * The latest solidified block when every quorum endpoint's solidified block is at or past\n   * `expiration` (a monotone predicate), else null.\n   */\n  async function passedExpiry(expiration: number): Promise<TronBlockHeader | null> {\n    const head = (await api.block('solid', undefined, {\n      ...PROOF,\n      quorumKey: (answer) => solidTimestamp(answer) >= expiration,\n    })) as TronBlockHeader;\n    return head.timestamp >= expiration ? head : null;\n  }\n\n  /**\n   * The first solidified block at or past `time`, at or below `hi` (an attested block at or\n   * past it). Block timestamps strictly increase, so \"at or past `time`\" is monotone in the\n   * height: a gallop down from the slot estimate, then a binary search. Every probe is\n   * an attested fixed-height read at or below `hi`, which every quorum endpoint has\n   * solidified, so none can stall; the slot spacing only picks the first probe.\n   */\n  async function firstAtOrAfter(\n    time: number,\n    hi: TronBlockHeader,\n  ): Promise<TronBlockHeader> {\n    let high = hi;\n    let low: TronBlockHeader | undefined;\n    let step = BigInt(Math.max(1, Math.floor((hi.timestamp - time) / SLOT_MS)));\n    while (low === undefined) {\n      if (high.number === 0n) return high;\n      const probe = await solidHeader(high.number > step ? high.number - step : 0n);\n      if (probe.timestamp < time) {\n        low = probe;\n      } else {\n        high = probe;\n        step *= 2n;\n      }\n    }\n    while (high.number - low.number > 1n) {\n      const mid = await solidHeader((low.number + high.number) / 2n);\n      if (mid.timestamp < time) low = mid;\n      else high = mid;\n    }\n    return high;\n  }\n\n  /**\n   * The first solidified block at or past `expiration`, or null while the quorum has not\n   * solidified past it. Only the predicate is attested: the latest block's height and time\n   * are one endpoint's word, so a block trailed by the peer skew is attested at its own height\n   * (a freshest endpoint then stalls nothing), and the search runs at or below it\n   * or, within the skew, up to the first block at the expiration, which every endpoint has\n   * solidified (bounded, whatever the endpoint claimed).\n   */\n  async function expiryBlock(expiration: number): Promise<TronBlockHeader | null> {\n    const seen = await passedExpiry(expiration);\n    if (!seen) return null;\n    let top = await solidHeader(seen.number > PEER_SKEW ? seen.number - PEER_SKEW : 0n);\n    if (top.timestamp >= expiration) return firstAtOrAfter(expiration, top);\n    while (top.timestamp < expiration) {\n      if (top.number >= seen.number) throw undecided();\n      top = await solidHeader(top.number + 1n);\n    }\n    return top;\n  }\n\n  /**\n   * No block above the attested `floor`, at or below `last` and `top`, holds `id`: walked by\n   * parent hash from the upper end, which must arrive at `floor`. Throws when anything cannot\n   * be decided. Every height read is below `top`, which every quorum endpoint has solidified.\n   */\n  async function absentAbove(\n    id: string,\n    floor: TronBlockHeader,\n    top: TronBlockHeader,\n    last: bigint,\n  ): Promise<void> {\n    const end = last < top.number ? last : top.number;\n    if (end <= floor.number) return;\n    const start = end === top.number ? top : await solidHeader(end);\n    let hash = start.id;\n    for (let height = start.number; height > floor.number; height -= 1n) {\n      const block = await finalBlockByHash(hash, height);\n      // Missing, or not the block the parent chain leads to: an endpoint is behind or lying.\n      if (!block || block.number !== height) throw undecided();\n      // In a solidified block, yet the index said nothing: it lags. Decide later.\n      if (block.transactions.includes(id)) throw undecided();\n      hash = block.parentHash;\n    }\n    // The walk is bound at both ends: it must arrive at the attested block below the window.\n    if (hash !== floor.id) {\n      throw contradiction('the scanned blocks do not lead to the reference block');\n    }\n  }\n\n  /**\n   * Absence proven by scan; throws when anything cannot be decided. `top`\n   * is the attested first block at or past the expiration: no block above it can hold `id`.\n   */\n  async function absent(id: string, bounds: Bounds, top: TronBlockHeader): Promise<void> {\n    const { reference, refBlockHash } = bounds;\n    /** The 24 h mark: only a block whose parent is at or after it can hold `id`. */\n    const dayMark = bounds.expiration - MAX_LIFETIME_MS;\n    // The stored height is the build-time head's claim: it bounds the scan only when the\n    // attested block there carries the signed hash bytes.\n    if (reference < top.number) {\n      const named = await solidHeader(reference);\n      if (hashBytes(named) === refBlockHash) {\n        // A reference older than a day (a build head that named an old block) is\n        // scanned only from the 24 h mark, as the search below does, never its whole window.\n        const floor =\n          named.timestamp < dayMark ? await firstAtOrAfter(dayMark, top) : named;\n        await absentAbove(id, floor, top, reference + TAPOS_WINDOW);\n        return;\n      }\n    }\n    // Otherwise, the heights TaPoS can match: the signed low 16 bits, below the top, from one\n    // TaPoS window below the first block within 24 h of the expiration (a block's parent is at\n    // or after it). Every block up to the top checks the reference against one of them.\n    const earliest = await firstAtOrAfter(dayMark, top);\n    const low16 = reference % TAPOS_WINDOW;\n    const from =\n      earliest.number + 1n > TAPOS_WINDOW ? earliest.number + 1n - TAPOS_WINDOW : 0n;\n    let height = from + ((low16 - (from % TAPOS_WINDOW) + TAPOS_WINDOW) % TAPOS_WINDOW);\n    for (; height < top.number; height += TAPOS_WINDOW) {\n      const candidate = await solidHeader(height);\n      if (hashBytes(candidate) !== refBlockHash) continue;\n      // Its TaPoS window, less the blocks whose parent is more than 24 h before the expiration.\n      const floor = candidate.number >= earliest.number ? candidate : earliest;\n      await absentAbove(id, floor, top, candidate.number + TAPOS_WINDOW);\n    }\n  }\n\n  return {\n    async finalizedHead() {\n      // The unanchored exception: one endpoint's view, trailed by the peer skew, attested.\n      const seen = (await api.block('solid', undefined, MONITOR)) as TronBlockHeader;\n      const head = await solidHeader(\n        seen.number > PEER_SKEW ? seen.number - PEER_SKEW : 0n,\n      );\n      return { height: head.number, hash: head.id, timestamp: head.timestamp };\n    },\n\n    async includedFinal(ref, ordering) {\n      // Bounded before any work; our own Attempt's ref is always a txID.\n      if (typeof ref.id !== 'string' || ref.id.length !== 64) throw undecided();\n      const id = ref.id.toLowerCase();\n      if (!TX_ID.test(id)) throw undecided();\n      const info = await api.transactionInfo('solid', id, PROOF);\n      if (info) {\n        const [header, tx] = await Promise.all([\n          api.block('solid', info.blockNumber, PROOF),\n          api.transaction('solid', id, PROOF),\n        ]);\n        if (!header || !tx) throw undecided();\n        // java-tron writes the block's time into each receipt (`blockTimeStamp`): a receipt\n        // dated otherwise is not from the solidified block at its height.\n        if (info.blockTimestamp !== header.timestamp) {\n          throw contradiction('a receipt does not match its solidified block');\n        }\n        // `verdictOf` pairs the receipt with the transaction by id, reads the verdict\n        // fields strictly and wants evidence that value moved; a contradiction decides\n        // nothing.\n        const verdict = verdictOf(ctx.codec, tx, info);\n        return {\n          included: true,\n          success: verdict.success,\n          blockHeight: info.blockNumber,\n          blockHash: header.id,\n          txHash: id,\n          ...(verdict.reason !== undefined ? { reason: verdict.reason } : {}),\n        };\n      }\n      const bounds = attemptBounds(ordering);\n      if (!bounds) throw undecided();\n      const top = await expiryBlock(bounds.expiration);\n      if (!top) throw undecided();\n      await absent(id, bounds, top);\n      return { included: false };\n    },\n\n    async slotConsumed() {\n      // Tron has no nonce or sequence: expiry is the only way an Attempt dies.\n      return false;\n    },\n\n    async expired(ordering: OrderingData) {\n      if (ordering.kind !== 'expiry' || !Number.isSafeInteger(ordering.expiresAtMs)) {\n        return false;\n      }\n      return (await expiryBlock(ordering.expiresAtMs as number)) !== null;\n    },\n\n    async blockHash(height, level) {\n      if (height < 0n || height > INT64_MAX) return null;\n      const header = await api.block(\n        level === 'finalized' ? 'solid' : 'full',\n        height,\n        PROOF,\n      );\n      return header?.id ?? null;\n    },\n  };\n}\n\nexport function createTronBlocks(ctx: TronContext): BlockSource {\n  return {\n    async header(height) {\n      const header = await ctx.api.block('full', height, MONITOR);\n      return header\n        ? {\n            height: header.number,\n            hash: header.id,\n            parentHash: header.parentId,\n            timestamp: header.timestamp,\n          }\n        : null;\n    },\n    async transactions(block, filter) {\n      // Genesis holds only the chain's initial allocations, which are not reported,\n      // and java-tron answers `{}` for its receipts, which a scanner would retry for ever.\n      if (block.height === 0n) return [];\n      const read = await ctx.api.blockWithTransactions(block.height, MONITOR);\n      if (!read || read.header.id !== block.hash) {\n        throw new ProviderError(\n          'PROVIDER_INCONSISTENT',\n          `block ${block.height} changed while scanning`,\n          { retryable: true },\n        );\n      }\n      // Receipts pair with transactions by id, never by position.\n      const infos = new Map(read.infos.map((info) => [info.id, info]));\n      const txs = read.transactions.map((tx) => {\n        const info = infos.get(tx.id);\n        if (!info) {\n          throw new ProviderError(\n            'PROVIDER_UNAVAILABLE',\n            'a scanned block lacks a receipt',\n          );\n        }\n        return decodeTransaction(ctx.codec, tx, info, block.hash);\n      });\n      if (!filter?.addresses?.length) return txs;\n      const wanted = new Set(filter.addresses.map((a) => toBase58Address(a)));\n      return txs.filter(\n        (tx) =>\n          wanted.has(String(tx.details.owner)) ||\n          tx.transfers.some((t) => wanted.has(t.to) || t.from.some((f) => wanted.has(f))),\n      );\n    },\n  };\n}\n\nconst CURSOR = /^([tx]):(.*)$/;\n/** The largest page TronGrid serves. */\nconst MAX_PAGE = 200;\n\n/**\n * TronGrid history, each entry re-read from the full node and decoded like any\n * transaction; confirmed (solidified) entries only (`historyPage`). Phase `t` is\n * `/transactions`: the account's own transactions, TRX sent to it and, for a contract\n * account, other accounts' calls to it. Phase `x` is `/transactions/trc20`: every TRC-20\n * transfer from or to it (a spender's `transferFrom` out of it included), less the account's\n * own calls, which phase `t` listed. A TRC-20 transfer a wallet only received is in phase `x`\n * alone (TronGrid, read-only on Nile, 2026-09-28), but a call to a contract account that moves\n * its own tokens comes in both phases, so callers dedupe on `transfer.id`.\n * Paging follows the raw page's fingerprint, never how many items survive the filter, and\n * an entry the node cannot serve yet decides nothing: dropping it would skip it for good.\n */\nexport function createTronHistory(\n  ctx: TronContext,\n  indexer: Transport,\n  getTransaction: (id: string) => Promise<DriverTransaction | null>,\n): AddressHistorySource {\n  return {\n    async list(address, options) {\n      const match = CURSOR.exec(options.cursor ?? 't:');\n      if (!match) throw new ConfigError('CONFIG_INVALID', 'not a Tron history cursor');\n      const phase = match[1] as 't' | 'x';\n      const fingerprint = match[2] as string;\n      const owner = toBase58Address(address);\n      const page = await historyPage(\n        indexer,\n        owner,\n        phase === 't' ? 'transactions' : 'trc20',\n        {\n          limit: Math.min(Math.max(Math.trunc(options.limit) || 1, 1), MAX_PAGE),\n          ...(fingerprint ? { fingerprint } : {}),\n        },\n        READ,\n      );\n      const items: DriverTransaction[] = [];\n      for (const id of page.ids) {\n        const tx = await getTransaction(id);\n        // The index lists it as confirmed: a node that serves nothing, or only its pool\n        // copy, is behind; listing that copy would move the cursor past it for good.\n        if (!tx || tx.observation.seen !== 'block') throw notServable();\n        // Phase x skips the account's own calls: phase t listed them.\n        if (!(phase === 'x' && tx.details.owner === owner)) items.push(tx);\n      }\n      const next = page.next ? `${phase}:${page.next}` : phase === 't' ? 'x:' : undefined;\n      return { items, ...(next !== undefined ? { next } : {}) };\n    },\n  };\n}\n"]}

package/dist/adapters/tron/protobuf.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The protobuf wire reader the Tron family shares: the codec (`codec.ts`) reads
+ * chain transactions with it, and the broadcast classifier (`errors.ts`) the bytes it sent.
+ * SDK-free, so the classifier never loads tronweb. Linear in the input: each
+ * length is checked against the bytes left before it is used, a varint stops at 64 bits,
+ * and field number 0, a group or an unknown wire type makes the message unreadable (`null`),
+ * as does a truncated field.
+ */
+/** A varint as a bigint, length-delimited bytes, or `null` for an opaque fixed-width field. */
+export type WireValue = bigint | Uint8Array | null;
+export interface WireField {
+    readonly field: number;
+    readonly value: WireValue;
+    /** The field's encoded length, tag included. */
+    readonly length: number;
+}
+/**
+ * What a reader does with a fixed-width field (wire types 1 and 5): `opaque` keeps it as a
+ * `null` value, for chain data that may carry fields the reader never reads (the codec);
+ * `refuse` makes the message unreadable, for a reader that names every field it accepts
+ * (the classifier).
+ */
+export type FixedWidth = 'opaque' | 'refuse';
+/** The wire type a known field must have (`singular`). */
+export type FieldKinds = Readonly<Record<number, 'varint' | 'bytes'>>;
+/** One protobuf message's fields, in order; `null` when the bytes do not read. */
+export declare function wireFields(bytes: Uint8Array, fixed: FixedWidth): WireField[] | null;
+/**
+ * A message whose fields are each singular, by number; `null` when the bytes do not read or
+ * a field number repeats, so a value is never guessed between protobuf's merge and last-wins
+ * rules. With `kinds`, only the listed fields are accepted, each of its wire type, and a
+ * fixed-width field is refused; without, any field is kept and a fixed-width one is opaque.
+ */
+export declare function singular(bytes: Uint8Array | null, kinds?: FieldKinds): Map<number, WireValue> | null;
+/** A field's bytes, or `null` when it is absent or not length-delimited. */
+export declare const bytesOf: (value: WireValue | undefined) => Uint8Array | null;

package/dist/adapters/tron/protobuf.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * The protobuf wire reader the Tron family shares: the codec (`codec.ts`) reads
+ * chain transactions with it, and the broadcast classifier (`errors.ts`) the bytes it sent.
+ * SDK-free, so the classifier never loads tronweb. Linear in the input: each
+ * length is checked against the bytes left before it is used, a varint stops at 64 bits,
+ * and field number 0, a group or an unknown wire type makes the message unreadable (`null`),
+ * as does a truncated field.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesOf = void 0;
+exports.wireFields = wireFields;
+exports.singular = singular;
+/** One protobuf message's fields, in order; `null` when the bytes do not read. */
+function wireFields(bytes, fixed) {
+    const out = [];
+    let i = 0;
+    const varint = () => {
+        let result = 0n;
+        for (let shift = 0n; shift < 64n; shift += 7n) {
+            const byte = bytes[i++];
+            // The tenth byte carries the 64th bit only.
+            if (byte === undefined || (shift === 63n && byte > 1))
+                return null;
+            result |= BigInt(byte & 0x7f) << shift;
+            if ((byte & 0x80) === 0)
+                return result;
+        }
+        return null;
+    };
+    while (i < bytes.length) {
+        const start = i;
+        const key = varint();
+        if (key === null || key >> 3n === 0n)
+            return null;
+        const wire = key & 7n;
+        let value;
+        if (wire === 0n) {
+            value = varint();
+            if (value === null)
+                return null;
+        }
+        else if (wire === 2n) {
+            const length = varint();
+            if (length === null || length > BigInt(bytes.length - i))
+                return null;
+            value = bytes.subarray(i, i + Number(length));
+            i += Number(length);
+        }
+        else if ((wire === 1n || wire === 5n) && fixed === 'opaque') {
+            i += wire === 1n ? 8 : 4;
+            if (i > bytes.length)
+                return null;
+            value = null;
+        }
+        else {
+            return null;
+        }
+        out.push({ field: Number(key >> 3n), value, length: i - start });
+    }
+    return out;
+}
+/**
+ * A message whose fields are each singular, by number; `null` when the bytes do not read or
+ * a field number repeats, so a value is never guessed between protobuf's merge and last-wins
+ * rules. With `kinds`, only the listed fields are accepted, each of its wire type, and a
+ * fixed-width field is refused; without, any field is kept and a fixed-width one is opaque.
+ */
+function singular(bytes, kinds) {
+    const fields = bytes ? wireFields(bytes, kinds ? 'refuse' : 'opaque') : null;
+    if (!fields)
+        return null;
+    const out = new Map();
+    for (const { field, value } of fields) {
+        if (out.has(field))
+            return null;
+        if (kinds) {
+            const kind = Object.hasOwn(kinds, field) ? kinds[field] : undefined;
+            if (kind === undefined || (kind === 'varint') !== (typeof value === 'bigint')) {
+                return null;
+            }
+        }
+        out.set(field, value);
+    }
+    return out;
+}
+/** A field's bytes, or `null` when it is absent or not length-delimited. */
+const bytesOf = (value) => value instanceof Uint8Array ? value : null;
+exports.bytesOf = bytesOf;
+//# sourceMappingURL=protobuf.js.map