@recoillink/sdk 0.0.0-stage → 45.0.1

package/dist/rpc/evm/utils.js

@@ -0,0 +1,338 @@
+import { assert, isNullish, rootLogger, sleep, } from '@recoillink/utils';
+import { assertIsContractAddress, isContractAddress, } from '../../contracts/contracts.js';
+import { LogBlockRangeTooLargeError } from '../../providers/SmartProvider/HyperlaneJsonRpcProvider.js';
+import { toNumber } from '../../utils/numbers.js';
+const logger = rootLogger.child({ module: 'rpc:evm:utils' });
+function toString(value, field) {
+    assert(typeof value === 'string', `Unable to convert ${field} to string`);
+    return value;
+}
+function toStringArray(value, field) {
+    assert(Array.isArray(value) && value.every((v) => typeof v === 'string'), `Unable to convert ${field} to string[]`);
+    return value;
+}
+// The lowest block the deployment search probes.
+const GENESIS_BLOCK_NUMBER = 0;
+/**
+ * Finds the block a contract was deployed in by bisecting `eth_getCode` over
+ * the chain's history.
+ *
+ * Every probe but the last few is a request for archive state, which an
+ * endpoint that prunes answers in one of two ways. If it fails the probe, this
+ * lookup fails rather than widening the subsequent log scan to genesis. If it
+ * reports no code at a height where the contract did exist, that successful
+ * response is indistinguishable from a genuine pre-deployment answer. Like any
+ * other RPC read, this search therefore assumes a successful response describes
+ * the requested block correctly.
+ */
+export async function getContractCreationBlockFromRpc(chain, contractAddress, multiProvider) {
+    await assertIsContractAddress(multiProvider, chain, contractAddress);
+    const provider = multiProvider.getProvider(chain);
+    const latestBlock = await provider.getBlockNumber();
+    let low = GENESIS_BLOCK_NUMBER;
+    let high = latestBlock;
+    let creationBlock = latestBlock;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        let isContract;
+        try {
+            isContract = await isContractAddress(multiProvider, chain, contractAddress, mid);
+        }
+        catch (error) {
+            logger.warn({ err: error }, `Unable to read the state of block ${mid} on chain ${chain} while searching for the deployment block of ${contractAddress}`);
+            throw error;
+        }
+        if (isContract) {
+            creationBlock = mid;
+            high = mid - 1;
+        }
+        else {
+            low = mid + 1;
+        }
+    }
+    return creationBlock;
+}
+const DEFAULT_LOG_PAGINATION_BLOCK_RANGE = 500;
+const MIN_LOG_PAGINATION_BLOCK_RANGE = 1;
+const LOG_PAGINATION_RETRY_BASE_MS = 100;
+const LOG_PAGINATION_RETRY_MAX_MS = 1_000;
+const MAX_TRANSIENT_LOG_READ_RETRIES = 3;
+// The narrowest span a failure naming neither a block range nor a result limit
+// is retried at. Shrinking on one is a guess that the signal list below missed
+// this provider's phrasing of a range rejection; an outage answers the same way
+// at every range, and unbounded that guess costs four attempts and their
+// backoffs at each of the twenty or so halvings down to one block.
+//
+// Bounding it by a count of halvings was only as strict as the range counted
+// from: three of the 500 block default stop at 62, but three of the 1,000,000
+// XERC20_LOG_SCAN_BLOCK_RANGE asks for stop at 125,000, above every cap a real
+// provider enforces, so on that path the guess could never reach a span that
+// would have worked. In blocks it means the same at both: from 1,000,000 it
+// still reaches 7,812 and 1,953, and so a 10,000 or 2,000 block cap, and from
+// 500 it still allows 500, 250, 125 and 62.
+//
+// A cap the registry declares never reaches here: the transport splits the
+// chunk at it and refuses with LogBlockRangeTooLargeError, which is recognised
+// and halves to one block unbounded. That covers flare's 30, the only declared
+// maxBlockRange below this figure.
+const MIN_UNRECOGNISED_FAILURE_BLOCK_RANGE = 100;
+const MAX_ERROR_INSPECTION_DEPTH = 4;
+const ERROR_TEXT_FIELDS = ['message', 'reason', 'body', 'details'];
+const ERROR_NESTED_FIELDS = ['error', 'cause', 'data', 'info'];
+const ERROR_HTTP_STATUS_FIELDS = ['status', 'statusCode'];
+// HTTP statuses with which a provider rejects the caller (401, 403) or says the
+// endpoint does not serve JSON-RPC at this url or verb (404, 405). Every one of
+// them answers the same way however often it is asked and over whatever span.
+const TERMINAL_HTTP_STATUSES = [401, 403, 404, 405];
+// The JSON-RPC code for a method the endpoint does not implement, which is how
+// the same rejection arrives when the transport itself answered 200.
+const METHOD_NOT_FOUND_RPC_CODE = -32601;
+// Lowercased fragments of the same rejections as they reach us when neither the
+// status code nor the JSON-RPC code survived the trip through ethers.
+const TERMINAL_ERROR_SIGNALS = [
+    'unauthorized',
+    'forbidden',
+    'invalid api key',
+    'invalid project id',
+    'authentication failed',
+    'must be authenticated',
+    'method not found',
+];
+// Lowercased fragments of the errors providers return when a single
+// eth_getLogs covers more blocks (or matches more logs) than they will serve.
+// Collected from Alchemy, Infura, QuickNode, Ankr, BlockPI and geth/erigon.
+const BLOCK_RANGE_ERROR_SIGNALS = [
+    'block range',
+    'blockrange',
+    'block_range',
+    'range of blocks',
+    'range too large',
+    'requested too many blocks',
+    'getlogs is limited to',
+    'query returned more than',
+    'query exceeds max results',
+    'response size exceeded',
+    'result set too large',
+    'too many results',
+    'too many logs',
+];
+// A public node phrases a span cap this way ('please limit your query to at
+// most 1000 blocks') and a throttle phrases a request cap the same way ('please
+// limit your query to 10 requests per second'), so on its own the fragment says
+// only that something about the query was too much.
+const AMBIGUOUS_QUERY_LIMIT_SIGNAL = 'limit your query to';
+// Which of the two it is, is decided by whether the message says anything about
+// a rate. Deciding it the other way round, by looking for a block or a result
+// named near the fragment, cannot be done on what is matched here: the text is
+// the whole flattened error chain, and for a getLogs failure that chain carries
+// SmartProvider's echo of the request params, whose fromBlock and toBlock keys
+// supply the word block whatever the provider actually said. None of the
+// fragments below appear in that echo.
+const REQUEST_RATE_ERROR_SIGNALS = [
+    'per second',
+    'per minute',
+    'too many requests',
+    'rate limit',
+    'query rate',
+    'throttl',
+];
+function collectErrorText(error, depth = 0) {
+    if (typeof error === 'string')
+        return error;
+    if (depth >= MAX_ERROR_INSPECTION_DEPTH)
+        return '';
+    if (typeof error !== 'object' || error === null)
+        return '';
+    const parts = [];
+    for (const field of ERROR_TEXT_FIELDS) {
+        const value = Reflect.get(error, field);
+        if (typeof value === 'string') {
+            parts.push(value);
+        }
+    }
+    for (const field of ERROR_NESTED_FIELDS) {
+        const value = Reflect.get(error, field);
+        if (!isNullish(value)) {
+            parts.push(collectErrorText(value, depth + 1));
+        }
+    }
+    return parts.join(' ');
+}
+function someNestedError(error, matches, depth = 0) {
+    if (depth >= MAX_ERROR_INSPECTION_DEPTH)
+        return false;
+    if (typeof error !== 'object' || error === null)
+        return false;
+    if (matches(error))
+        return true;
+    return ERROR_NESTED_FIELDS.some((field) => {
+        const value = Reflect.get(error, field);
+        return !isNullish(value) && someNestedError(value, matches, depth + 1);
+    });
+}
+function isTerminalErrorNode(error) {
+    if (Reflect.get(error, 'isRecoverable') === false)
+        return true;
+    // ethers puts its own string codes on `code`, so only the numeric JSON-RPC
+    // one is a method rejection.
+    if (Reflect.get(error, 'code') === METHOD_NOT_FOUND_RPC_CODE)
+        return true;
+    return ERROR_HTTP_STATUS_FIELDS.some((field) => {
+        const value = Reflect.get(error, field);
+        return typeof value === 'number' && TERMINAL_HTTP_STATUSES.includes(value);
+    });
+}
+/**
+ * True when the failure is about who is asking or about what the endpoint
+ * serves rather than about the span that was asked for, so neither retrying nor
+ * narrowing the block range can change the outcome and the error has to surface
+ * at once.
+ *
+ * `isRecoverable === false` is the convention `retryAsync` already honours on
+ * the error it is handed, and is read here through the same nested walk as
+ * {@link isBlockRangeError} so that a wrapped error is still seen, which
+ * `retryAsync` itself does not do. {@link LogBlockRangeTooLargeError} carries
+ * that flag too, because repeating the identical request is exactly what it
+ * refuses, so a caller has to ask {@link isBlockRangeError} first and reach
+ * this only for what no narrower request recovers.
+ *
+ * The status, code and message matching beside
+ * it is deliberately narrow: missing a terminal error only costs the retries and
+ * halvings it takes to reach {@link MIN_UNRECOGNISED_FAILURE_BLOCK_RANGE},
+ * whereas a false positive fails a read that shrinking the range would have
+ * completed.
+ */
+export function isTerminalLogReadError(error) {
+    if (someNestedError(error, isTerminalErrorNode))
+        return true;
+    const text = collectErrorText(error).toLowerCase();
+    return TERMINAL_ERROR_SIGNALS.some((signal) => text.includes(signal));
+}
+/**
+ * True when the provider rejected a log query because it spanned too many
+ * blocks or matched too many logs, i.e. when retrying the same chunk is
+ * pointless and the block range has to shrink.
+ *
+ * Among the failures that are not terminal this decides how quickly and how far
+ * the range shrinks, never whether it shrinks: an unrecognised failure is
+ * retried at the unchanged range first, the range is halved once those retries
+ * are spent, and the halving stops at
+ * {@link MIN_UNRECOGNISED_FAILURE_BLOCK_RANGE} instead of at the one block
+ * minimum. Recognising a rate limit as a range error therefore costs a
+ * premature reduction that is sticky for the rest of the scan, and failing to
+ * recognise a provider's phrasing of a range error costs the retries that
+ * precede the same reduction, and the read itself where the cap is narrower
+ * than that floor.
+ *
+ * The one rejection raised inside this repository, {@link
+ * LogBlockRangeTooLargeError}, is matched by type as well as by message, and is
+ * looked for through the same nested walk because SmartProvider surfaces it as
+ * the `cause` of its combined error. The message match is what covers every
+ * external provider, so the type check is only there to keep a reword of that
+ * one message from turning halving into a hard failure.
+ */
+export function isBlockRangeError(error) {
+    if (someNestedError(error, (node) => node instanceof LogBlockRangeTooLargeError)) {
+        return true;
+    }
+    const text = collectErrorText(error).toLowerCase();
+    if (BLOCK_RANGE_ERROR_SIGNALS.some((signal) => text.includes(signal))) {
+        return true;
+    }
+    return (text.includes(AMBIGUOUS_QUERY_LIMIT_SIGNAL) &&
+        !REQUEST_RATE_ERROR_SIGNALS.some((signal) => text.includes(signal)));
+}
+export async function getLogsFromRpc({ chain, contractAddress, multiProvider, fromBlock, topic, toBlock, range = DEFAULT_LOG_PAGINATION_BLOCK_RANGE, }) {
+    assert(Number.isInteger(range) && range >= MIN_LOG_PAGINATION_BLOCK_RANGE, `Log pagination range must be an integer of at least ${MIN_LOG_PAGINATION_BLOCK_RANGE}, got ${range}`);
+    const provider = multiProvider.getProvider(chain);
+    let currentStartBlock = fromBlock;
+    const endBlock = toBlock ?? (await provider.getBlockNumber());
+    let currentRange = range;
+    let transientRetries = 0;
+    const logs = [];
+    while (currentStartBlock <= endBlock) {
+        const currentEndBlock = Math.min(currentStartBlock + currentRange - 1, endBlock);
+        try {
+            const currentLogs = await provider.getLogs({
+                address: contractAddress,
+                fromBlock: currentStartBlock,
+                toBlock: currentEndBlock,
+                topics: [topic],
+            });
+            logs.push(...currentLogs);
+        }
+        catch (error) {
+            // Asked before the terminal check, which a range rejection also answers:
+            // the identical request is refused however often it is repeated, and
+            // LogBlockRangeTooLargeError says so with the same isRecoverable = false
+            // that check reads. What recovers it is a narrower request, so it belongs
+            // on the halving ladder rather than in the branch for failures no request
+            // can recover from.
+            const rangeRejected = isBlockRangeError(error);
+            // Retrying and halving both assume the read can still succeed. A failure
+            // that rejects the caller instead of the query never does, and would
+            // otherwise burn the retry budget once per range all the way down to the
+            // one block minimum before surfacing.
+            if (!rangeRejected && isTerminalLogReadError(error)) {
+                throw error;
+            }
+            // The end block clips the last chunk, so what the provider rejected is
+            // the span actually asked for rather than the configured range. Halving
+            // the range instead would leave a clipped chunk unchanged and re-issue
+            // the identical request, once per factor of two between the two.
+            const attemptedRange = currentEndBlock - currentStartBlock + 1;
+            if (!rangeRejected && transientRetries < MAX_TRANSIENT_LOG_READ_RETRIES) {
+                const backoffMs = Math.min(LOG_PAGINATION_RETRY_BASE_MS * 2 ** transientRetries, LOG_PAGINATION_RETRY_MAX_MS);
+                transientRetries++;
+                logger.warn({ err: error }, `Failed to read logs for ${contractAddress} on chain ${chain} between blocks ${currentStartBlock} and ${currentEndBlock}, retrying attempt ${transientRetries} of ${MAX_TRANSIENT_LOG_READ_RETRIES} in ${backoffMs}ms at the unchanged block range of ${attemptedRange}`);
+                await sleep(backoffMs);
+                continue;
+            }
+            const narrowestRetriedRange = rangeRejected
+                ? MIN_LOG_PAGINATION_BLOCK_RANGE
+                : MIN_UNRECOGNISED_FAILURE_BLOCK_RANGE;
+            if (attemptedRange <= narrowestRetriedRange) {
+                throw error;
+            }
+            // Providers advertise wildly different maximums, so the halved range is
+            // kept for the remaining chunks instead of being re-discovered on each
+            // one. An unrecognised failure lands here too once its retries are spent,
+            // because the alternative reading, that the signal list simply misses
+            // this provider's phrasing, is only ruled out by trying a smaller range.
+            const reducedRange = Math.max(Math.floor(attemptedRange / 2), MIN_LOG_PAGINATION_BLOCK_RANGE);
+            logger.warn({ err: error }, rangeRejected
+                ? `Provider rejected the block range for ${contractAddress} on chain ${chain} between blocks ${currentStartBlock} and ${currentEndBlock}, retrying with a block range of ${reducedRange}`
+                : `Failed to read logs for ${contractAddress} on chain ${chain} between blocks ${currentStartBlock} and ${currentEndBlock} after ${MAX_TRANSIENT_LOG_READ_RETRIES} retries at a block range of ${attemptedRange}, retrying with a block range of ${reducedRange}`);
+            currentRange = reducedRange;
+            transientRetries = 0;
+            continue;
+        }
+        transientRetries = 0;
+        currentStartBlock = currentEndBlock + 1;
+    }
+    return logs.map((rawLog) => {
+        return {
+            address: toString(rawLog.address, 'address'),
+            blockNumber: toNumber(rawLog.blockNumber, 'blockNumber'),
+            data: toString(rawLog.data, 'data'),
+            logIndex: toNumber(rawLog.logIndex, 'logIndex'),
+            topics: toStringArray(rawLog.topics, 'topics'),
+            transactionHash: toString(rawLog.transactionHash, 'transactionHash'),
+            transactionIndex: toNumber(rawLog.transactionIndex, 'transactionIndex'),
+        };
+    });
+}
+export function viemLogFromGetEventLogsResponse(log) {
+    return {
+        address: log.address,
+        data: log.data,
+        blockNumber: BigInt(log.blockNumber),
+        transactionHash: log.transactionHash,
+        logIndex: Number(log.logIndex),
+        transactionIndex: Number(log.transactionIndex),
+        topics: log.topics,
+        blockHash: null,
+        removed: false,
+    };
+}
+//# sourceMappingURL=utils.js.map

package/dist/rpc/evm/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/rpc/evm/utils.ts"],"names":[],"mappings":"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"}

package/dist/rpc/evm/utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=utils.test.d.ts.map

package/dist/rpc/evm/utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.test.d.ts","sourceRoot":"","sources":["../../../src/rpc/evm/utils.test.ts"],"names":[],"mappings":""}