@defillama/sdk 5.0.236 → 5.0.240

package/build/chains/starknet.js

@@ -1,884 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.cairoErc20Abis = exports.erc20AbisCairo1 = exports.erc20Abis = exports.DEFAULT_EVENTS_CHUNK_SIZE = exports.number = exports.FIELD_PRIME = exports.ADDR_BOUND = exports.BATCH_CHUNK_SIZE = exports.AGGREGATE_CHUNK_SIZE = exports.DEFAULT_MULTICALL_ADDRESS = exports.DEFAULT_ENDPOINTS = exports.CHAIN = void 0;
-exports.getEndpoints = getEndpoints;
-exports.getMulticallAddress = getMulticallAddress;
-exports.toBigInt = toBigInt;
-exports.toHex = toHex;
-exports.addAddressPadding = addAddressPadding;
-exports.validateAndParseAddress = validateAndParseAddress;
-exports.isStarknetAddress = isStarknetAddress;
-exports.starknetKeccak = starknetKeccak;
-exports.getSelectorFromName = getSelectorFromName;
-exports.parseUint256 = parseUint256;
-exports.shortStringToFelt = shortStringToFelt;
-exports.feltToShortString = feltToShortString;
-exports.feltArrToStr = feltArrToStr;
-exports.encodeCalldata = encodeCalldata;
-exports.decodeOutput = decodeOutput;
-exports.toBlockId = toBlockId;
-exports.formCallBody = formCallBody;
-exports.parseOutput = parseOutput;
-exports.rpc = rpc;
-exports.getBlockNumber = getBlockNumber;
-exports.getBlock = getBlock;
-exports.getBlockAtTimestamp = getBlockAtTimestamp;
-exports.getNonce = getNonce;
-exports.getClassHashAt = getClassHashAt;
-exports.call = call;
-exports.multiCall = multiCall;
-exports.getLogs = getLogs;
-/**
- * Starknet client: dependency-free JSON-RPC transport + Cairo ABI codec.
- *
- * Replaces (and consolidates) these per-repo copies:
- *   - DefiLlama-Adapters  projects/helper/utils/starknet.js   (codec: selectors, addresses, encodeCalldata, decodeOutput)
- *   - DefiLlama-Adapters  projects/helper/chain/starknet.js   (call, multiCall via aggregator / batched, rpc, getBlockNumber, getLogs)
- *   - DefiLlama-Adapters  projects/helper/env.js              (STARKNET_RPC / STARKNET_MULTICALL defaults)
- *   - coins               src/adapters/utils/starknet.ts      (feltArrToStr, cairoErc20Abis, aggregate result layout)
- *   - defi                l2/utils.ts                         (starknetU256ToNumber, hardcoded total_supply / aggregate selectors)
- *   - peggedassets-server src/adapters/peggedAssets/helper/starknet.js (defaultAbis shape)
- *
- * Only the chain plumbing is ported: no TVL helpers (sumTokens / dexExport live
- * with their callers) and no on-disk log cache.
- *
- * Decoding mirrors starknet.js v5 (CallData.parse) so existing ABIs keep working:
- *   - scalars (felt, felt252, uN, ContractAddress, ...) decode to BigInt
- *   - core::bool decodes to boolean
- *   - core::integer::u256 decodes to a single BigInt (low + high << 128)
- *   - bare Cairo 0 "Uint256" WITHOUT a struct definition decodes as ONE felt
- *     (that is what starknet.js did, and adapters such as jediswap reordered
- *     their ABIs around it); with a struct definition it decodes to { low, high }
- *   - structs decode to objects keyed by member name, tuples to objects keyed
- *     by index (or member name for Cairo 0 named tuples), arrays to arrays
- *   - a function with a single unnamed output returns the value directly,
- *     otherwise an object keyed by output name
- *
- * Env: `STARKNET_RPC` (comma separated list, rotated on failure) overrides
- * `DEFAULT_ENDPOINTS`; `STARKNET_MULTICALL` overrides the aggregator address;
- * `STARKNET_RPC_CONCURRENCY` overrides the (default 1) request concurrency.
- */
-const ethers_1 = require("ethers");
-const env_1 = require("../util/env");
-const debugLog_1 = require("../util/debugLog");
-const rpc_1 = require("./rpc");
-// ---------------------------------------------------------------------------
-// config
-// ---------------------------------------------------------------------------
-exports.CHAIN = 'starknet';
-exports.DEFAULT_ENDPOINTS = [
-    'https://api.zan.top/public/starknet-mainnet',
-    'https://starknet-mainnet.public.blastapi.io',
-];
-// On-chain Multicall aggregator. Collapses N starknet_call executions into a
-// single one (the node executes all sub-calls in one call frame), which is the
-// real cost win when the RPC bills per sub-call rather than per HTTP request.
-// aggregate(calls: Array<Call>) -> (block_number: u64, results: Array<Span<felt252>>)
-// NOTE: aggregate reverts atomically: if any sub-call reverts, the whole call
-// reverts, so multiCall falls back to per-call batching to preserve permitFailure.
-exports.DEFAULT_MULTICALL_ADDRESS = '0x01a33330996310a1e3fa1df5b16c1e07f0491fdd20c441126e02613b948f0225';
-exports.AGGREGATE_CHUNK_SIZE = 50;
-exports.BATCH_CHUNK_SIZE = 25;
-const CHUNK_SLEEP_MS = 200;
-function getEndpoints() {
-    return (0, rpc_1.getEndpoints)(exports.CHAIN, exports.DEFAULT_ENDPOINTS);
-}
-function getMulticallAddress() {
-    return (0, env_1.getEnvValue)('STARKNET_MULTICALL', exports.DEFAULT_MULTICALL_ADDRESS);
-}
-const rpcOptions = () => ({ chain: exports.CHAIN, defaultEndpoints: exports.DEFAULT_ENDPOINTS });
-// Public Starknet RPCs are stingy, so everything funnels through one limiter
-// (override with STARKNET_RPC_CONCURRENCY).
-const limiter = () => (0, rpc_1.getLimiter)('STARKNET', 1);
-// ---------------------------------------------------------------------------
-// numbers / addresses / selectors
-// ---------------------------------------------------------------------------
-const ZERO = BigInt(0);
-const ONE = BigInt(1);
-const SHIFT_128 = BigInt(128);
-const MASK_250 = (ONE << BigInt(250)) - ONE;
-const MASK_128 = (ONE << SHIFT_128) - ONE;
-exports.ADDR_BOUND = (ONE << BigInt(251)) - BigInt(256);
-exports.FIELD_PRIME = (ONE << BigInt(251)) + BigInt(17) * (ONE << BigInt(192)) + ONE;
-function toBigInt(value) {
-    if (typeof value === 'bigint')
-        return value;
-    if (typeof value === 'number')
-        return BigInt(value);
-    if (typeof value === 'string')
-        return BigInt(value.trim());
-    if (typeof value === 'boolean')
-        return value ? ONE : ZERO;
-    throw new Error(`starknet: cannot convert ${value} to BigInt`);
-}
-function toHex(value) {
-    return '0x' + toBigInt(value).toString(16);
-}
-function addAddressPadding(address) {
-    return '0x' + toBigInt(address).toString(16).padStart(64, '0');
-}
-function validateAndParseAddress(address) {
-    let n;
-    try {
-        n = toBigInt(address);
-    }
-    catch (e) {
-        throw new Error(`Starknet Address is not a number: ${address}`);
-    }
-    if (n < ZERO || n >= exports.ADDR_BOUND)
-        throw new Error(`Starknet Address out of range: ${address}`);
-    return addAddressPadding(n);
-}
-/**
- * Loose check for a Starknet address: 0x-prefixed hex, non-zero, inside the
- * address bound, and not shaped like an EVM address (exactly 40 hex chars).
- */
-function isStarknetAddress(value) {
-    if (typeof value !== 'string')
-        return false;
-    const v = value.trim();
-    if (!/^0x[0-9a-fA-F]{1,64}$/.test(v))
-        return false;
-    if (v.length === 42)
-        return false;
-    const n = BigInt(v);
-    return n > ZERO && n < exports.ADDR_BOUND;
-}
-/** starknet_keccak: keccak256 of the utf8 name, masked to 250 bits */
-function starknetKeccak(str) {
-    return BigInt((0, ethers_1.keccak256)((0, ethers_1.toUtf8Bytes)(str))) & MASK_250;
-}
-function getSelectorFromName(name) {
-    return toHex(starknetKeccak(name));
-}
-/** u256 as { low, high } object or [low, high] felt pair -> bigint */
-function parseUint256(value) {
-    if (Array.isArray(value)) {
-        if (value.length < 2)
-            throw new Error('starknet: u256 needs [low, high]');
-        return toBigInt(value[0]) + (toBigInt(value[1]) << SHIFT_128);
-    }
-    if (value !== null && typeof value === 'object')
-        return toBigInt(value.low) + (toBigInt(value.high) << SHIFT_128);
-    return toBigInt(value);
-}
-/** Cairo short string (<= 31 utf8 bytes) -> hex felt */
-function shortStringToFelt(str) {
-    const bytes = Buffer.from(str, 'utf8');
-    if (bytes.length > 31)
-        throw new Error(`starknet: short string too long: ${str}`);
-    return '0x' + (bytes.toString('hex') || '0');
-}
-/** hex/decimal/bigint felt -> utf8 short string (leading zero bytes dropped) */
-function feltToShortString(felt) {
-    const n = toBigInt(felt);
-    if (n === ZERO)
-        return '';
-    let hex = n.toString(16);
-    if (hex.length % 2)
-        hex = '0' + hex;
-    return Buffer.from(hex, 'hex').toString('utf8');
-}
-/** concatenate an array of short-string felts (e.g. a felt* name) */
-function feltArrToStr(felts) {
-    return felts.reduce((memo, felt) => memo + feltToShortString(felt), '');
-}
-exports.number = {
-    toHex,
-    toBigInt,
-    toBN: toBigInt,
-    hexToDecimalString: (v) => toBigInt(v).toString(),
-};
-const isLen = (name) => /_len$/.test(name !== null && name !== void 0 ? name : '');
-const isCairo1Type = (type) => type.includes('::');
-const isTypeArray = (type) => /\*/.test(type) || type.startsWith('core::array::Array::') || type.startsWith('core::array::Span::');
-const isTypeTuple = (type) => /^\(.*\)$/.test(type);
-const isTypeU256 = (type) => type === 'core::integer::u256';
-const isTypeLegacyU256 = (type) => type === 'Uint256';
-const isTypeBool = (type) => type === 'core::bool';
-const isTypeOption = (type) => type.startsWith('core::option::Option::');
-const isTypeResult = (type) => type.startsWith('core::result::Result::');
-function getArrayType(type) {
-    if (isCairo1Type(type))
-        return type.substring(type.indexOf('<') + 1, type.lastIndexOf('>'));
-    return type.replace('*', '');
-}
-// "(a, (b, c), core::array::Array::<x>)" -> ["a", "(b, c)", "core::array::Array::<x>"]
-// Cairo 0 named tuples "(x: felt, y: felt)" -> [{ name: 'x', type: 'felt' }, ...]
-function extractTupleMemberTypes(type) {
-    const inner = type.replace(/\s/g, '').slice(1, -1);
-    const members = [];
-    let depth = 0, current = '';
-    for (const ch of inner) {
-        if (ch === '(' || ch === '<')
-            depth++;
-        else if (ch === ')' || ch === '>')
-            depth--;
-        if (ch === ',' && depth === 0) {
-            members.push(current);
-            current = '';
-        }
-        else
-            current += ch;
-    }
-    if (current)
-        members.push(current);
-    return members.map((m) => {
-        if (isCairo1Type(m) || !m.includes(':'))
-            return m;
-        const idx = m.indexOf(':');
-        return { name: m.slice(0, idx), type: m.slice(idx + 1) };
-    });
-}
-const memberType = (m) => typeof m === 'string' ? m : m.type;
-const memberName = (m, i) => typeof m === 'string' ? i : m.name;
-function getAbiStructs(abi) {
-    const structs = {};
-    abi.forEach((entry) => { if (entry && entry.type === 'struct')
-        structs[entry.name] = entry; });
-    return structs;
-}
-function getAbiEnums(abi) {
-    const enums = {};
-    abi.forEach((entry) => { if (entry && entry.type === 'enum')
-        enums[entry.name] = entry; });
-    delete enums['core::bool'];
-    return enums;
-}
-// ---------------------------------------------------------------------------
-// calldata encoding
-// ---------------------------------------------------------------------------
-const isHexString = (v) => /^0x[0-9a-fA-F]+$/.test(v);
-const isDecimalString = (v) => /^\d+$/.test(v);
-/** encode a single felt (returns hex string) */
-function felt(value) {
-    if (typeof value === 'bigint' || typeof value === 'number' || typeof value === 'boolean')
-        return toHex(value);
-    if (typeof value === 'string') {
-        const v = value.trim();
-        if (isHexString(v) || isDecimalString(v))
-            return toHex(v);
-        return shortStringToFelt(v);
-    }
-    throw new Error(`starknet: cannot encode ${JSON.stringify(value)} as felt`);
-}
-function encodeU256(value) {
-    if (value !== null && typeof value === 'object' && !Array.isArray(value))
-        return [felt(value.low), felt(value.high)];
-    if (Array.isArray(value))
-        return [felt(value[0]), felt(value[1])];
-    const n = toBigInt(value);
-    return [toHex(n & MASK_128), toHex(n >> SHIFT_128)];
-}
-function encodeValue(value, type, structs, enums) {
-    var _a;
-    if (value === undefined)
-        throw new Error(`starknet: missing parameter for type ${type}`);
-    if (isTypeU256(type) || isTypeLegacyU256(type))
-        return encodeU256(value);
-    if (Array.isArray(value)) {
-        const itemType = getArrayType(type);
-        const out = [felt(value.length)];
-        value.forEach((v) => out.push(...encodeValue(v, itemType, structs, enums)));
-        return out;
-    }
-    if (structs[type] && ((_a = structs[type].members) === null || _a === void 0 ? void 0 : _a.length)) {
-        const out = [];
-        structs[type].members.forEach((m) => out.push(...encodeValue(value[m.name], m.type, structs, enums)));
-        return out;
-    }
-    if (isTypeTuple(type)) {
-        const memberTypes = extractTupleMemberTypes(type);
-        const elements = Object.values(value);
-        if (elements.length !== memberTypes.length)
-            throw new Error(`starknet: tuple size mismatch for ${type}`);
-        const out = [];
-        memberTypes.forEach((m, i) => out.push(...encodeValue(elements[i], memberType(m), structs, enums)));
-        return out;
-    }
-    if (enums[type])
-        throw new Error(`starknet: enum inputs are not supported (${type})`);
-    if (typeof value === 'object')
-        throw new Error(`starknet: parameter ${JSON.stringify(value)} does not match abi type ${type}`);
-    return [felt(value)];
-}
-function asFnAbi(abiOrParams, key) {
-    if (Array.isArray(abiOrParams))
-        return { name: '', type: 'function', [key]: abiOrParams };
-    return abiOrParams;
-}
-/**
- * Encode function arguments into calldata (array of hex felts).
- * @param fnAbi   function abi entry (or just its `inputs` array)
- * @param params  positional arguments
- * @param allAbi  struct/enum definitions referenced by the function
- */
-function encodeCalldata(fnAbi, params = [], allAbi = []) {
-    var _a;
-    const abi = asFnAbi(fnAbi, 'inputs');
-    if (!Array.isArray(params))
-        params = [params];
-    const structs = getAbiStructs([abi, ...allAbi]);
-    const enums = getAbiEnums([abi, ...allAbi]);
-    const inputs = (_a = abi.inputs) !== null && _a !== void 0 ? _a : [];
-    const calldata = [];
-    let idx = 0;
-    for (const input of inputs) {
-        // Cairo 0: `foo_len` inputs are derived from the array that follows
-        if (isLen(input.name) && !isCairo1Type(input.type))
-            continue;
-        calldata.push(...encodeValue(params[idx++], input.type, structs, enums));
-    }
-    return calldata;
-}
-function next(it) {
-    const { value, done } = it.next();
-    if (done)
-        throw new Error('starknet: response too short for abi');
-    return value;
-}
-function decodeBase(type, it) {
-    if (isTypeBool(type))
-        return Boolean(BigInt(next(it)));
-    if (isTypeU256(type)) {
-        const low = BigInt(next(it));
-        const high = BigInt(next(it));
-        return (high << SHIFT_128) + low;
-    }
-    return BigInt(next(it));
-}
-function decodeValue(it, type, structs, enums) {
-    var _a, _b;
-    if (type === '()')
-        return {};
-    if (isTypeU256(type))
-        return decodeBase(type, it);
-    if (isTypeArray(type)) {
-        const itemType = getArrayType(type);
-        const len = BigInt(next(it));
-        const out = [];
-        while (out.length < len)
-            out.push(decodeValue(it, itemType, structs, enums));
-        return out;
-    }
-    if (structs[type]) {
-        const out = {};
-        ((_a = structs[type].members) !== null && _a !== void 0 ? _a : []).forEach((m) => { out[m.name] = decodeValue(it, m.type, structs, enums); });
-        return out;
-    }
-    if (enums[type]) {
-        const variantNum = Number(BigInt(next(it)));
-        const variant = ((_b = enums[type].variants) !== null && _b !== void 0 ? _b : [])[variantNum];
-        if (!variant)
-            throw new Error(`starknet: unknown variant ${variantNum} for ${type}`);
-        const content = decodeValue(it, variant.type, structs, enums);
-        if (isTypeOption(type))
-            return variantNum === 0 ? content : undefined;
-        if (isTypeResult(type))
-            return variantNum === 0 ? { Ok: content } : { Err: content };
-        return { [variant.name]: content };
-    }
-    if (isTypeTuple(type)) {
-        const out = {};
-        extractTupleMemberTypes(type).forEach((m, i) => {
-            out[memberName(m, i)] = decodeValue(it, memberType(m), structs, enums);
-        });
-        return out;
-    }
-    return decodeBase(type, it);
-}
-function decodeField(it, output, structs, enums, parsed) {
-    var _a;
-    const { name, type } = output;
-    if (isLen(name))
-        return BigInt(next(it));
-    if (structs[type] || isTypeTuple(type) || enums[type])
-        return decodeValue(it, type, structs, enums);
-    if (isTypeArray(type)) {
-        if (isCairo1Type(type))
-            return decodeValue(it, type, structs, enums);
-        // Cairo 0 `foo: felt*` is preceded by a `foo_len: felt` output
-        const out = [];
-        const len = (_a = parsed[`${name}_len`]) !== null && _a !== void 0 ? _a : ZERO;
-        const itemType = type.replace('*', '');
-        while (out.length < len)
-            out.push(decodeValue(it, itemType, structs, enums));
-        return out;
-    }
-    return decodeBase(type, it);
-}
-/**
- * Decode a starknet_call result according to the function abi.
- * @param fnAbi   function abi entry (or just its `outputs` array)
- * @param result  array of felts returned by the node
- * @param allAbi  struct/enum definitions referenced by the function
- */
-function decodeOutput(fnAbi, result, allAbi = []) {
-    var _a;
-    const abi = asFnAbi(fnAbi, 'outputs');
-    const structs = getAbiStructs([abi, ...allAbi]);
-    const enums = getAbiEnums([abi, ...allAbi]);
-    const it = result.flat()[Symbol.iterator]();
-    const parsed = {};
-    const outputs = (_a = abi.outputs) !== null && _a !== void 0 ? _a : [];
-    outputs.forEach((output, idx) => {
-        var _a;
-        const key = (_a = output.name) !== null && _a !== void 0 ? _a : idx;
-        parsed[key] = decodeField(it, output, structs, enums, parsed);
-        if (parsed[key] && parsed[`${key}_len`])
-            delete parsed[`${key}_len`];
-    });
-    return Object.keys(parsed).length === 1 && 0 in parsed ? parsed[0] : parsed;
-}
-// ---------------------------------------------------------------------------
-// call bodies / output post-processing
-// ---------------------------------------------------------------------------
-function toBlockId(block) {
-    if (block === undefined || block === null)
-        return 'latest';
-    if (typeof block === 'number')
-        return { block_number: block };
-    if (typeof block === 'string') {
-        if (['latest', 'pending', 'pre_confirmed', 'l1_accepted'].includes(block))
-            return block;
-        if (/^0x[0-9a-fA-F]+$/.test(block))
-            return { block_hash: block };
-        if (/^\d+$/.test(block))
-            return { block_number: +block };
-        throw new Error(`starknet: invalid block id ${block}`);
-    }
-    return block;
-}
-/**
- * Build a `starknet_call` JSON-RPC request. `abi.customInput === 'address'`
- * passes params through as raw felts (u256 inputs pre-split by the caller).
- */
-function formCallBody({ abi, target, params = [], allAbi = [], block }, id = 0) {
-    if (!abi)
-        throw new Error('starknet: missing abi');
-    if (!target)
-        throw new Error(`starknet: missing target for ${abi.name}`);
-    if ((params || params === 0) && !Array.isArray(params))
-        params = [params];
-    if (params === undefined || params === null)
-        params = [];
-    let calldata = abi.customInput === 'address' ? params : encodeCalldata(abi, params, allAbi);
-    // The RPC rejects calldata felts without a 0x prefix, normalize everything.
-    calldata = calldata.map((i) => toHex(i));
-    const requestData = {
-        contract_address: String(target).toLowerCase(),
-        entry_point_selector: getSelectorFromName(abi.name),
-        calldata,
-    };
-    return { jsonrpc: '2.0', id, method: 'starknet_call', params: [requestData, toBlockId(block)] };
-}
-/**
- * Decode a call result and apply the legacy post-processing: BigInts at depth 1
- * become strings, a single non-Cairo 1 output is unwrapped, `Uint256` outputs
- * (or `customType: 'Uint256' | 'number'`) become numbers, `customType: 'address'`
- * is padded.
- */
-function parseOutput(result, abi, allAbi = [], { permitFailure = false, error } = {}) {
-    var _a, _b;
-    if (!result) {
-        if (permitFailure)
-            return null;
-        throw new Error(`Starknet call ${(_a = abi === null || abi === void 0 ? void 0 : abi.name) !== null && _a !== void 0 ? _a : ''} failed: ${formatRpcError(error) || 'no result'}`);
-    }
-    let response = decodeOutput(abi, result, allAbi);
-    if (typeof response === 'bigint')
-        response = response.toString();
-    else if (response && typeof response === 'object') {
-        for (const key in response) {
-            if (typeof response[key] === 'bigint')
-                response[key] = response[key].toString();
-        }
-    }
-    const outputs = (_b = abi.outputs) !== null && _b !== void 0 ? _b : [];
-    if (outputs.length === 1 && !outputs[0].type.includes('::')) {
-        const name = outputs[0].name;
-        if (name !== undefined && response && typeof response === 'object')
-            response = response[name];
-        if (outputs[0].type === 'Uint256')
-            return +response;
-    }
-    if (outputs.length === 1) {
-        switch (abi.customType) {
-            case 'address': return validateAndParseAddress(response);
-            case 'Uint256':
-            case 'number': return +response;
-        }
-    }
-    return response;
-}
-function formatRpcError(e) {
-    var _a, _b, _c, _d, _e, _f;
-    if (!e)
-        return '';
-    const data = (_a = e.data) !== null && _a !== void 0 ? _a : (_b = e.error) === null || _b === void 0 ? void 0 : _b.data;
-    const message = (_c = e.message) !== null && _c !== void 0 ? _c : (_d = e.error) === null || _d === void 0 ? void 0 : _d.message;
-    const revert = (_f = (_e = data === null || data === void 0 ? void 0 : data.revert_error) !== null && _e !== void 0 ? _e : data === null || data === void 0 ? void 0 : data.execution_error) !== null && _f !== void 0 ? _f : (typeof data === 'string' ? data : undefined);
-    if (revert) {
-        const text = typeof revert === 'string' ? revert : JSON.stringify(revert);
-        return message ? `${message}: ${text}` : text;
-    }
-    return message ? String(message) : JSON.stringify(e);
-}
-// ---------------------------------------------------------------------------
-// json-rpc
-// ---------------------------------------------------------------------------
-/** Raw JSON-RPC call against the Starknet endpoints (STARKNET_RPC rotation + retries) */
-async function rpc(method, params = []) {
-    try {
-        return await (0, rpc_1.jsonRpc)(method, params, rpcOptions());
-    }
-    catch (e) {
-        if (e instanceof rpc_1.JsonRpcError)
-            throw new Error(`Starknet ${method} failed: ${formatRpcError(e)}`);
-        throw e;
-    }
-}
-async function getBlockNumber() {
-    return +(await rpc('starknet_blockNumber'));
-}
-async function getBlock({ blockNumber, block } = {}) {
-    const id = toBlockId(block !== null && block !== void 0 ? block : blockNumber);
-    const res = await rpc('starknet_getBlockWithTxHashes', [id]);
-    return { number: +res.block_number, timestamp: +res.timestamp, hash: res.block_hash };
-}
-/** Last block whose timestamp is <= `timestamp` (binary search, no cache) */
-async function getBlockAtTimestamp({ timestamp }) {
-    if (timestamp > 1e12)
-        timestamp = Math.floor(timestamp / 1000);
-    let hi = await getBlock({ blockNumber: 'latest' });
-    if (hi.timestamp <= timestamp)
-        return { number: hi.number, timestamp: hi.timestamp };
-    let lo = { number: 0, timestamp: 0 };
-    while (hi.number - lo.number > 1) {
-        const mid = Math.floor((lo.number + hi.number) / 2);
-        const b = await getBlock({ blockNumber: mid });
-        if (b.timestamp <= timestamp)
-            lo = { number: b.number, timestamp: b.timestamp };
-        else
-            hi = b;
-    }
-    if (lo.number === 0 && lo.timestamp === 0) {
-        const b = await getBlock({ blockNumber: 0 });
-        if (b.timestamp > timestamp)
-            throw new Error(`starknet: timestamp ${timestamp} is before genesis`);
-        return { number: b.number, timestamp: b.timestamp };
-    }
-    return lo;
-}
-async function getNonce({ address, block }) {
-    return rpc('starknet_getNonce', [toBlockId(block), String(address).toLowerCase()]);
-}
-async function getClassHashAt({ address, block }) {
-    return rpc('starknet_getClassHashAt', [toBlockId(block), String(address).toLowerCase()]);
-}
-// ---------------------------------------------------------------------------
-// call / multiCall
-// ---------------------------------------------------------------------------
-async function rawCall(request, block, permitFailure, abiName) {
-    try {
-        return await (0, rpc_1.jsonRpc)('starknet_call', [request, toBlockId(block)], rpcOptions());
-    }
-    catch (e) {
-        if (permitFailure) {
-            (0, debugLog_1.debugLog)(`[starknet] call ${abiName} on ${request.contract_address} failed (permitted): ${formatRpcError(e)}`);
-            return null;
-        }
-        throw new Error(`Starknet call ${abiName} on ${request.contract_address} failed: ${formatRpcError(e)}`);
-    }
-}
-async function call({ abi, target, params = [], allAbi = [], permitFailure = false, block }) {
-    const body = formCallBody({ abi, target, params, allAbi, block });
-    const result = await limiter()(() => rawCall(body.params[0], block, permitFailure, abi.name));
-    return parseOutput(result, abi, allAbi, { permitFailure });
-}
-function normalizeCalls({ abi: rootAbi, target: rootTarget, calls, allAbi = [] }) {
-    return calls.map((callArgs, i) => {
-        var _a;
-        let item;
-        if (callArgs === null || typeof callArgs !== 'object') {
-            if (!rootTarget)
-                item = { target: callArgs, params: [], abi: rootAbi, allAbi };
-            else
-                item = { target: rootTarget, params: callArgs, abi: rootAbi, allAbi };
-        }
-        else {
-            const { target, params, abi } = callArgs;
-            item = { target: (target || rootTarget), params, abi: (abi || rootAbi), allAbi: (_a = callArgs.allAbi) !== null && _a !== void 0 ? _a : allAbi };
-        }
-        if (!item.abi)
-            throw new Error(`starknet: multiCall item ${i} has no abi`);
-        if (!item.target)
-            throw new Error(`starknet: multiCall item ${i} has no target`);
-        return item;
-    });
-}
-/**
- * Run many `starknet_call`s. By default one on-chain `aggregate` call per 50
- * sub-calls; if the aggregator reverts (any sub-call reverting reverts the whole
- * batch) or `useAggregator` is false, falls back to JSON-RPC batches of 25 so
- * `permitFailure` still applies per call. Results are in call order.
- */
-async function multiCall(options) {
-    const { calls = [], permitFailure = false, useAggregator = true, block } = options;
-    if (!calls.length)
-        return [];
-    const normalized = normalizeCalls(options);
-    return limiter()(async () => {
-        if (useAggregator) {
-            try {
-                return await aggregateMultiCall(normalized, block);
-            }
-            catch (e) {
-                (0, debugLog_1.debugLog)(`[starknet] aggregate multicall failed, falling back to batched calls: ${formatRpcError(e)}`);
-            }
-        }
-        return batchedMultiCall(normalized, permitFailure, block);
-    });
-}
-/** One starknet_call to the on-chain aggregator covering all sub-calls. */
-async function aggregateMultiCall(calls, block) {
-    const aggregator = getMulticallAddress();
-    const aggSelector = getSelectorFromName('aggregate');
-    const response = [];
-    const chunks = (0, rpc_1.sliceIntoChunks)(calls, exports.AGGREGATE_CHUNK_SIZE);
-    let offset = 0;
-    for (let c = 0; c < chunks.length; c++) {
-        const chunk = chunks[c];
-        if (c > 0)
-            await (0, rpc_1.sleep)(CHUNK_SLEEP_MS);
-        // Build the Call[] calldata: [n, (to, selector, calldata_len, ...calldata) x n]
-        const aggCalldata = [toHex(chunk.length)];
-        chunk.forEach((item) => {
-            const body = formCallBody(item).params[0];
-            aggCalldata.push(body.contract_address, body.entry_point_selector, toHex(body.calldata.length), ...body.calldata);
-        });
-        const request = { contract_address: aggregator, entry_point_selector: aggSelector, calldata: aggCalldata };
-        const result = await (0, rpc_1.jsonRpc)('starknet_call', [request, toBlockId(block)], rpcOptions());
-        if (!Array.isArray(result))
-            throw new Error('aggregate failed: empty result');
-        // result layout: [block_number, results_len, (span_len, ...span_felts) x results_len]
-        let i = 1; // skip block_number
-        const resultsLen = Number(toBigInt(result[i++]));
-        if (resultsLen !== chunk.length)
-            throw new Error(`aggregate returned ${resultsLen} results for ${chunk.length} calls`);
-        for (let j = 0; j < resultsLen; j++) {
-            const spanLen = Number(toBigInt(result[i++]));
-            const span = result.slice(i, i + spanLen);
-            i += spanLen;
-            const item = chunk[j];
-            response[offset + j] = parseOutput(span, item.abi, item.allAbi);
-        }
-        offset += chunk.length;
-    }
-    return response;
-}
-/** N individual starknet_call requests packed into JSON-RPC batches. */
-async function batchedMultiCall(calls, permitFailure, block) {
-    const bodies = calls.map((item, id) => formCallBody({ ...item, block }, id));
-    const response = new Array(calls.length);
-    const chunks = (0, rpc_1.sliceIntoChunks)(bodies, exports.BATCH_CHUNK_SIZE);
-    for (let c = 0; c < chunks.length; c++) {
-        const chunk = chunks[c];
-        if (c > 0)
-            await (0, rpc_1.sleep)(CHUNK_SLEEP_MS);
-        let results;
-        if (chunk.length === 1) {
-            // some providers (e.g. lava.build) answer a one-element batch with a bare
-            // object; use a plain call for that case
-            const body = chunk[0];
-            results = [await rawCall(body.params[0], block, permitFailure, calls[body.id].abi.name)];
-        }
-        else {
-            try {
-                results = await (0, rpc_1.jsonRpcBatch)(chunk.map((b) => ({ method: b.method, params: b.params, id: b.id })), { ...rpcOptions(), permitFailure });
-            }
-            catch (e) {
-                if (e instanceof rpc_1.JsonRpcError)
-                    throw new Error(`Starknet call ${e.method} failed: ${formatRpcError(e)}`);
-                throw e;
-            }
-        }
-        chunk.forEach((body, i) => {
-            const id = body.id;
-            const item = calls[id];
-            response[id] = parseOutput(results[i], item.abi, item.allAbi, { permitFailure });
-        });
-    }
-    return response;
-}
-// ---------------------------------------------------------------------------
-// events
-// ---------------------------------------------------------------------------
-/** starknet_getEvents page size; public providers reject larger pages ("Requested page size is too big") */
-exports.DEFAULT_EVENTS_CHUNK_SIZE = 1000;
-const MIN_EVENTS_CHUNK_SIZE = 100;
-function isPageSizeError(e) {
-    var _a, _b;
-    const message = String((_b = (_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e) !== null && _b !== void 0 ? _b : '').toLowerCase();
-    return message.includes('page size') || message.includes('chunk_size') || message.includes('chunk size');
-}
-/**
- * Fetch events emitted by `target` via `starknet_getEvents`, following
- * `continuation_token` until the range [fromBlock, toBlock] is exhausted.
- * Returns raw events: { block_number, transaction_hash, from_address, keys, data }.
- */
-async function getLogs({ target, fromBlock, toBlock, topics, keys, chunkSize = exports.DEFAULT_EVENTS_CHUNK_SIZE }) {
-    if (!target)
-        throw new Error('Missing target!');
-    if (fromBlock === undefined || fromBlock === null)
-        throw new Error('Missing fromBlock!');
-    if (!keys && topics)
-        keys = [topics];
-    const keyFilter = (keys !== null && keys !== void 0 ? keys : []).map((k) => (Array.isArray(k) ? k : [k]).map((i) => toHex(i)));
-    const address = String(target).toLowerCase();
-    return limiter()(async () => {
-        var _a;
-        const end = toBlock !== null && toBlock !== void 0 ? toBlock : await getBlockNumber();
-        if (fromBlock > end)
-            return [];
-        const filter = {
-            from_block: { block_number: fromBlock },
-            to_block: { block_number: end },
-            address,
-            keys: keyFilter,
-            chunk_size: chunkSize,
-        };
-        const logs = [];
-        let pages = 0;
-        while (true) {
-            let page;
-            try {
-                page = await rpc('starknet_getEvents', [filter]);
-            }
-            catch (e) {
-                // providers cap chunk_size at different values; shrink and retry the same page
-                if (isPageSizeError(e) && filter.chunk_size > MIN_EVENTS_CHUNK_SIZE) {
-                    filter.chunk_size = Math.max(MIN_EVENTS_CHUNK_SIZE, Math.floor(filter.chunk_size / 2));
-                    (0, debugLog_1.debugLog)(`[starknet] getLogs page size rejected, retrying with chunk_size ${filter.chunk_size}`);
-                    continue;
-                }
-                throw e;
-            }
-            logs.push(...((_a = page === null || page === void 0 ? void 0 : page.events) !== null && _a !== void 0 ? _a : []));
-            pages++;
-            if (!(page === null || page === void 0 ? void 0 : page.continuation_token))
-                break;
-            filter.continuation_token = page.continuation_token;
-        }
-        (0, debugLog_1.debugLog)(`[starknet] getLogs ${address} [${fromBlock}, ${end}]: ${logs.length} events in ${pages} page(s)`);
-        return logs;
-    });
-}
-// ---------------------------------------------------------------------------
-// ERC20 ABIs
-// ---------------------------------------------------------------------------
-/**
- * Cairo 0 style ERC20 ABIs (camelCase entrypoints, `felt` / `Uint256` types).
- * `balanceOf` uses `customInput: 'address'` so the owner felt is passed through
- * untouched; `decimals` casts to a number.
- */
-exports.erc20Abis = {
-    balanceOf: {
-        name: 'balanceOf',
-        type: 'function',
-        inputs: [{ name: 'account', type: 'felt' }],
-        outputs: [{ name: 'balance', type: 'Uint256' }],
-        stateMutability: 'view',
-        customInput: 'address',
-    },
-    totalSupply: {
-        name: 'totalSupply',
-        type: 'function',
-        inputs: [],
-        outputs: [{ name: 'totalSupply', type: 'Uint256' }],
-        stateMutability: 'view',
-    },
-    decimals: {
-        name: 'decimals',
-        type: 'function',
-        inputs: [],
-        outputs: [{ name: 'decimals', type: 'felt' }],
-        stateMutability: 'view',
-        customType: 'number',
-    },
-    name: {
-        name: 'name',
-        type: 'function',
-        inputs: [],
-        outputs: [{ name: 'name', type: 'felt' }],
-        stateMutability: 'view',
-    },
-    symbol: {
-        name: 'symbol',
-        type: 'function',
-        inputs: [],
-        outputs: [{ name: 'symbol', type: 'felt' }],
-        stateMutability: 'view',
-    },
-    allowance: {
-        name: 'allowance',
-        type: 'function',
-        inputs: [{ name: 'owner', type: 'felt' }, { name: 'spender', type: 'felt' }],
-        outputs: [{ name: 'remaining', type: 'Uint256' }],
-        stateMutability: 'view',
-    },
-};
-/**
- * Cairo 1 style ERC20 ABIs (snake_case entrypoints, `core::` types). u256
- * outputs decode to a bigint (returned as a decimal string by `call`).
- */
-exports.erc20AbisCairo1 = {
-    balanceOf: {
-        name: 'balance_of',
-        type: 'function',
-        inputs: [{ name: 'account', type: 'core::starknet::contract_address::ContractAddress' }],
-        outputs: [{ type: 'core::integer::u256' }],
-        state_mutability: 'view',
-    },
-    totalSupply: {
-        name: 'total_supply',
-        type: 'function',
-        inputs: [],
-        outputs: [{ type: 'core::integer::u256' }],
-        state_mutability: 'view',
-    },
-    decimals: {
-        name: 'decimals',
-        type: 'function',
-        inputs: [],
-        outputs: [{ type: 'core::integer::u8' }],
-        state_mutability: 'view',
-        customType: 'number',
-    },
-    name: {
-        name: 'name',
-        type: 'function',
-        inputs: [],
-        outputs: [{ type: 'core::felt252' }],
-        state_mutability: 'view',
-    },
-    symbol: {
-        name: 'symbol',
-        type: 'function',
-        inputs: [],
-        outputs: [{ type: 'core::felt252' }],
-        state_mutability: 'view',
-    },
-    allowance: {
-        name: 'allowance',
-        type: 'function',
-        inputs: [
-            { name: 'owner', type: 'core::starknet::contract_address::ContractAddress' },
-            { name: 'spender', type: 'core::starknet::contract_address::ContractAddress' },
-        ],
-        outputs: [{ type: 'core::integer::u256' }],
-        state_mutability: 'view',
-    },
-};
-/** alias matching the coins repo export */
-exports.cairoErc20Abis = exports.erc20AbisCairo1;