@snovon/solast 0.2.0

package/dist/detectors/skim-token-balance.js

@@ -0,0 +1,788 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SkimTokenBalanceDetector = void 0;
+const access_control_1 = require("./_common/access-control");
+const RULE_ID = 'skim-token-balance';
+const PAT_USE_SITE = `${RULE_ID}/use-site`;
+const PAT_PAIR_SIDE = `${RULE_ID}/pair-side`;
+const PAT_UNRECONCILED_SELF_BALANCE = `${RULE_ID}/unreconciled-self-balance-payout`;
+const SOURCE = 'x-2023-08-24-gss-skim-token-balance';
+const ACCESS_CONTROL_MODIFIERS = new Set([
+    'onlyowner', 'onlyowners', 'onlyrole', 'onlyadmin', 'onlyauthorized',
+    'authorized', 'auth', 'onlyoperator', 'onlyoperators', 'onlygovernance',
+    'onlygovernor', 'onlyguardian', 'onlymanager', 'onlytrusted',
+    'onlytimelock', 'onlydeployer', 'onlykeeper',
+]);
+const REENTRANCY_GUARD_MODIFIERS = new Set([
+    'nonreentrant', 'noreentrant', 'noreentry', 'reentrancyguard',
+    'lock', 'locked', 'mutex',
+]);
+class SkimTokenBalanceDetector {
+    id = RULE_ID;
+    patternKey = RULE_ID;
+    supportedAstKinds = ['parser', 'solc'];
+    scanAst(ast, file, sourceText) {
+        if (!ast || typeof ast !== 'object')
+            return [];
+        if (Object.keys(ast).length === 0)
+            return [];
+        const findings = [];
+        const lineOffsets = buildLineOffsets(sourceText);
+        const contracts = collectContracts(ast);
+        const hasInSourceDeflationaryToken = contracts.some(contract => !isInterfaceLike(contract) && contractHasPairConditionalTransfer(contract));
+        for (const contract of contracts) {
+            if (isInterfaceLike(contract))
+                continue;
+            const contractName = getName(contract) || '<anonymous>';
+            for (const fn of getContractFunctions(contract)) {
+                if (!isExternallyReachable(fn))
+                    continue;
+                const body = getFunctionBody(fn);
+                if (!body)
+                    continue;
+                const fnName = getName(fn) || '';
+                if (!fnName)
+                    continue;
+                let hit = findUseSiteSkim(body);
+                if (!hit && !hasAccessControlGuard(fn, body) && !hasReentrancyGuard(fn)) {
+                    hit = findUnreconciledSelfBalancePayout(body, contract);
+                }
+                if (!hit && hasInSourceDeflationaryToken) {
+                    if (!hasAccessControlGuard(fn) && !hasReentrancyGuard(fn)) {
+                        hit = findPairSideSkim(body, contract);
+                    }
+                }
+                if (!hit)
+                    continue;
+                const loc = getLoc(hit.node, lineOffsets) || getLoc(fn, lineOffsets) || { line: 0, column: 0 };
+                findings.push({
+                    file,
+                    contract: contractName,
+                    'function': fnName,
+                    line: loc.line,
+                    endLine: loc.line,
+                    column: loc.column,
+                    pattern: hit.pattern,
+                    confidence: 'high',
+                    ruleId: RULE_ID,
+                    severity: hit.pattern === PAT_UNRECONCILED_SELF_BALANCE ? 'high' : 'error',
+                    message: messageFor(hit.pattern, contractName, fnName),
+                    rationale: rationaleFor(hit.pattern),
+                    suggestedFix: remediationFor(hit.pattern),
+                    contractName,
+                    functionName: fnName,
+                    sourceLocation: { line: loc.line, column: loc.column },
+                    findingId: '',
+                    contractHash: '',
+                    source: SOURCE,
+                    provenance: SOURCE,
+                });
+            }
+        }
+        return findings;
+    }
+}
+exports.SkimTokenBalanceDetector = SkimTokenBalanceDetector;
+function messageFor(pattern, contractName, fnName) {
+    if (pattern === PAT_UNRECONCILED_SELF_BALANCE) {
+        return `Function '${contractName}.${fnName}' pays a caller-benefiting sink from the contract's full live self-balance without reserve reconciliation or a guard.`;
+    }
+    if (pattern === PAT_USE_SITE) {
+        return `Function '${contractName}.${fnName}' transfers tokens to a pair and then calls 'skim' on that same pair, matching the gss balance-excess extraction shape.`;
+    }
+    return `Function '${contractName}.${fnName}' computes a skimmable amount from a pair's token balance and transfers it out, while a co-located token contract drifts the pair's balance on transfers — the gss skim-token-balance vulnerability shape.`;
+}
+function rationaleFor(pattern) {
+    if (pattern === PAT_UNRECONCILED_SELF_BALANCE) {
+        return 'The function reads `balanceOf(address(this))` or `address(this).balance` and uses the unreconciled whole balance as the amount for a payout or mint to the caller. Attackers can inflate live balance with donations or flash-loan top-ups and skim value that is not backed by tracked reserves.';
+    }
+    if (pattern === PAT_USE_SITE) {
+        return 'Reproduces the gss attack use-site: the contract pushes tokens into a pair to inflate the pair-held balance above the recorded reserve, then calls `skim` to harvest the excess to an attacker-controlled recipient.';
+    }
+    return 'Pair-side `skim` releases `balanceOf(pair) - reserve` without re-syncing the reserve before the transfer. When the paired token applies a tax or burn on transfers to the pair (deflationary on-pair-transfer), the pair accumulates a recoverable excess that any caller can drain with `skim` and a follow-up `sync`.';
+}
+function remediationFor(pattern) {
+    if (pattern === PAT_UNRECONCILED_SELF_BALANCE) {
+        return 'Pay only a reconciled reserve delta such as `balanceOf(address(this)) - reserve`, update accounting before value leaves, or restrict emergency skim paths with access control and reentrancy protection.';
+    }
+    if (pattern === PAT_USE_SITE) {
+        return 'Treat any flow that pushes tokens into a pair and then calls `skim`/`sync` on that pair as an attack signature; do not exposed it from a permissionless entry point.';
+    }
+    return 'Update the reserve to match the post-transfer balance before performing the token transfer (CEI), and gate `skim` behind an access-controlled rescue or a reentrancy-guarded sync, so a deflationary token cannot be drained by a permissionless skim.';
+}
+function findUseSiteSkim(body) {
+    const transferTargets = new Set();
+    let foundNode = null;
+    function visit(node) {
+        if (foundNode)
+            return;
+        if (!node || typeof node !== 'object')
+            return;
+        if (isFunctionCall(node)) {
+            const callee = unwrapCallOptions(getCallee(node));
+            if (isMemberAccess(callee)) {
+                const memberName = String(callee.memberName || '');
+                const args = getCallArguments(node);
+                if (memberName === 'transfer' && args.length >= 2) {
+                    const destName = identifierName(unwrapAddressCast(args[0]));
+                    if (destName)
+                        transferTargets.add(destName);
+                }
+                else if (memberName === 'skim' && args.length >= 1) {
+                    const baseExpr = getMemberAccessBase(callee);
+                    const recvName = identifierName(baseExpr) || identifierName(unwrapInterfaceCast(baseExpr));
+                    if (recvName && transferTargets.has(recvName)) {
+                        foundNode = node;
+                        return;
+                    }
+                }
+            }
+        }
+        for (const child of childrenOf(node))
+            visit(child);
+    }
+    visit(body);
+    return foundNode ? { node: foundNode, pattern: PAT_USE_SITE } : null;
+}
+function findUnreconciledSelfBalancePayout(body, contract) {
+    const stateVars = collectStateVariableNames(contract);
+    const selfAliases = new Set();
+    const balanceVars = new Set();
+    const safeDeltaVars = new Set();
+    let foundNode = null;
+    function visit(node) {
+        if (foundNode)
+            return;
+        if (!node || typeof node !== 'object')
+            return;
+        if (isNode(node, 'VariableDeclarationStatement')) {
+            const varNames = getVariableDeclarationNames(node);
+            const initialValue = node.initialValue ?? node.expression ?? null;
+            if (initialValue && varNames.length > 0) {
+                if (isSelfAddressExpression(initialValue, selfAliases)) {
+                    for (const name of varNames)
+                        selfAliases.add(name);
+                }
+                else if (isUnreconciledSelfBalanceAmount(initialValue, balanceVars, selfAliases)) {
+                    for (const name of varNames)
+                        balanceVars.add(name);
+                }
+                else if (isReserveReconciledAmount(initialValue, balanceVars, selfAliases, stateVars)) {
+                    for (const name of varNames)
+                        safeDeltaVars.add(name);
+                }
+            }
+        }
+        else if (isNode(node, 'Assignment')) {
+            const left = node.leftHandSide ?? node.left;
+            const right = node.rightHandSide ?? node.right;
+            const name = identifierName(left);
+            if (name && right) {
+                if (isSelfAddressExpression(right, selfAliases)) {
+                    selfAliases.add(name);
+                }
+                else if (isUnreconciledSelfBalanceAmount(right, balanceVars, selfAliases)) {
+                    balanceVars.add(name);
+                    safeDeltaVars.delete(name);
+                }
+                else if (isReserveReconciledAmount(right, balanceVars, selfAliases, stateVars)) {
+                    safeDeltaVars.add(name);
+                    balanceVars.delete(name);
+                }
+            }
+        }
+        if (isUserBenefitingPayoutCall(node, balanceVars, safeDeltaVars, selfAliases, stateVars)) {
+            foundNode = node;
+            return;
+        }
+        for (const child of childrenOf(node))
+            visit(child);
+    }
+    visit(body);
+    return foundNode ? { node: foundNode, pattern: PAT_UNRECONCILED_SELF_BALANCE } : null;
+}
+function getVariableDeclarationNames(node) {
+    const out = [];
+    for (const variable of node?.variables || []) {
+        const name = String(variable?.name || variable?.identifier?.name || '');
+        if (name)
+            out.push(name);
+    }
+    if (node?.declarations) {
+        for (const variable of node.declarations) {
+            const name = String(variable?.name || variable?.identifier?.name || '');
+            if (name)
+                out.push(name);
+        }
+    }
+    return out;
+}
+function isUserBenefitingPayoutCall(node, balanceVars, safeDeltaVars, selfAliases, stateVars) {
+    if (!isFunctionCall(node))
+        return false;
+    const callee = unwrapCallOptions(getCallee(node));
+    const args = getCallArguments(node);
+    if (isMemberAccess(callee)) {
+        const member = String(callee.memberName || '');
+        if ((member === 'transfer' || member === 'safeTransfer') && args.length >= 2) {
+            return isCallerBeneficiary(args[0]) &&
+                isDangerousPayoutAmount(args[1], balanceVars, safeDeltaVars, selfAliases, stateVars);
+        }
+        if ((member === 'transfer' || member === 'send') && args.length >= 1) {
+            return isCallerBeneficiary(getMemberAccessBase(callee)) &&
+                isDangerousPayoutAmount(args[0], balanceVars, safeDeltaVars, selfAliases, stateVars);
+        }
+    }
+    const name = getCallName(callee).toLowerCase();
+    if ((name === '_mint' || name === 'mint') && args.length >= 2) {
+        return isCallerBeneficiary(args[0]) &&
+            isDangerousPayoutAmount(args[1], balanceVars, safeDeltaVars, selfAliases, stateVars);
+    }
+    return false;
+}
+function isDangerousPayoutAmount(expr, balanceVars, safeDeltaVars, selfAliases, stateVars) {
+    if (!expr)
+        return false;
+    const name = identifierName(expr);
+    if (name && safeDeltaVars.has(name))
+        return false;
+    if (isReserveReconciledAmount(expr, balanceVars, selfAliases, stateVars))
+        return false;
+    return isUnreconciledSelfBalanceAmount(expr, balanceVars, selfAliases);
+}
+function isUnreconciledSelfBalanceAmount(expr, balanceVars, selfAliases) {
+    if (!expr || typeof expr !== 'object')
+        return false;
+    const name = identifierName(expr);
+    if (name && balanceVars.has(name))
+        return true;
+    if (isSelfBalanceExpression(expr, selfAliases))
+        return true;
+    return false;
+}
+function isReserveReconciledAmount(expr, balanceVars, selfAliases, stateVars) {
+    if (!isNode(expr, 'BinaryOperation') || String(expr.operator || '') !== '-')
+        return false;
+    const left = getBinLeft(expr);
+    const right = getBinRight(expr);
+    if (!isUnreconciledSelfBalanceAmount(left, balanceVars, selfAliases))
+        return false;
+    return expressionReferencesStateVariable(right, stateVars);
+}
+function expressionReferencesStateVariable(expr, stateVars) {
+    if (!expr || typeof expr !== 'object')
+        return false;
+    const name = identifierName(expr) || rootIdentifierName(expr);
+    if (name && stateVars.has(name))
+        return true;
+    return walkAny(expr, node => {
+        const innerName = identifierName(node) || rootIdentifierName(node);
+        return !!innerName && stateVars.has(innerName);
+    });
+}
+function isSelfBalanceExpression(expr, selfAliases) {
+    if (isBalanceOfSelfCall(expr, selfAliases))
+        return true;
+    if (!isMemberAccess(expr))
+        return false;
+    if (String(expr.memberName || '') !== 'balance')
+        return false;
+    return isSelfAddressExpression(getMemberAccessBase(expr), selfAliases);
+}
+function isBalanceOfSelfCall(node, selfAliases) {
+    if (!isBalanceOfCall(node))
+        return false;
+    const args = getCallArguments(node);
+    if (args.length < 1)
+        return false;
+    return isSelfAddressExpression(args[0], selfAliases);
+}
+function isSelfAddressExpression(expr, selfAliases) {
+    if (!expr)
+        return false;
+    if (isNode(expr, 'Identifier')) {
+        const name = String(expr.name || '');
+        return name === 'this' || selfAliases.has(name);
+    }
+    if (!isFunctionCall(expr))
+        return false;
+    const callee = getCallee(expr);
+    const args = getCallArguments(expr);
+    if (args.length !== 1)
+        return false;
+    return getCallName(callee).toLowerCase() === 'address' && isSelfAddressExpression(args[0], selfAliases);
+}
+function isCallerBeneficiary(expr) {
+    if (!expr)
+        return false;
+    if (isMsgSenderExpression(expr))
+        return true;
+    if (!isFunctionCall(expr))
+        return false;
+    const args = getCallArguments(expr);
+    if (args.length !== 1)
+        return false;
+    const calleeName = getCallName(getCallee(expr)).toLowerCase();
+    return (calleeName === 'payable' || calleeName === 'address') && isMsgSenderExpression(args[0]);
+}
+function isMsgSenderExpression(expr) {
+    if (!isMemberAccess(expr))
+        return false;
+    if (String(expr.memberName || '') !== 'sender')
+        return false;
+    const base = getMemberAccessBase(expr);
+    return isNode(base, 'Identifier') && String(base.name || '') === 'msg';
+}
+function getCallName(callee) {
+    if (!callee)
+        return '';
+    if (isNode(callee, 'Identifier'))
+        return String(callee.name || '');
+    if (isNode(callee, 'ElementaryTypeNameExpression')) {
+        const tn = callee.typeName;
+        if (typeof tn === 'string')
+            return tn;
+        return String(tn?.name || tn?.typeDescriptions?.typeString || '');
+    }
+    if (isNode(callee, 'UserDefinedTypeName'))
+        return String(callee.namePath || callee.name || '');
+    if (isMemberAccess(callee))
+        return String(callee.memberName || '');
+    return '';
+}
+function findPairSideSkim(body, contract) {
+    const stateVars = collectStateVariableNames(contract);
+    let sawBalanceOf = false;
+    let sawStateAssignmentBeforeTransfer = false;
+    let transferCallNode = null;
+    function visit(node) {
+        if (transferCallNode)
+            return;
+        if (!node || typeof node !== 'object')
+            return;
+        if (isBalanceOfCall(node)) {
+            sawBalanceOf = true;
+        }
+        if (isAssignmentToStateVariable(node, stateVars)) {
+            sawStateAssignmentBeforeTransfer = true;
+        }
+        if (isExternalTransferCall(node)) {
+            transferCallNode = node;
+            return;
+        }
+        for (const child of childrenOf(node))
+            visit(child);
+    }
+    visit(body);
+    if (!transferCallNode)
+        return null;
+    if (!sawBalanceOf)
+        return null;
+    if (sawStateAssignmentBeforeTransfer)
+        return null;
+    return { node: transferCallNode, pattern: PAT_PAIR_SIDE };
+}
+function contractHasPairConditionalTransfer(contract) {
+    const stateVarNames = collectStateVariableNames(contract);
+    if (stateVarNames.size === 0)
+        return false;
+    for (const fn of getContractFunctions(contract)) {
+        if (!isExternallyReachable(fn))
+            continue;
+        if (getName(fn) !== 'transfer')
+            continue;
+        const params = getParameters(fn);
+        const addressParamNames = new Set(params.filter(isAddressParameter).map(p => String(p.name || '')).filter(Boolean));
+        if (addressParamNames.size === 0)
+            continue;
+        const body = getFunctionBody(fn);
+        if (!body)
+            continue;
+        if (bodyHasPairEqualityCheck(body, addressParamNames, stateVarNames))
+            return true;
+    }
+    return false;
+}
+function bodyHasPairEqualityCheck(body, addressParams, stateVars) {
+    return walkAny(body, node => {
+        if (!isNode(node, 'BinaryOperation'))
+            return false;
+        const op = String(node.operator || '');
+        if (op !== '==' && op !== '!=')
+            return false;
+        const left = getBinLeft(node);
+        const right = getBinRight(node);
+        return paramVsState(left, right, addressParams, stateVars) ||
+            paramVsState(right, left, addressParams, stateVars);
+    });
+}
+function paramVsState(maybeParam, maybeState, addressParams, stateVars) {
+    if (!isNode(maybeParam, 'Identifier'))
+        return false;
+    if (!addressParams.has(String(maybeParam.name || '')))
+        return false;
+    if (!isNode(maybeState, 'Identifier'))
+        return false;
+    return stateVars.has(String(maybeState.name || ''));
+}
+function isAssignmentToStateVariable(node, stateVars) {
+    if (!node || typeof node !== 'object')
+        return false;
+    let left;
+    if (isNode(node, 'Assignment')) {
+        left = node.leftHandSide ?? node.left;
+    }
+    else if (isNode(node, 'BinaryOperation')) {
+        const op = String(node.operator || '');
+        if (!isAssignmentOperator(op))
+            return false;
+        left = node.left;
+    }
+    else {
+        return false;
+    }
+    if (!left)
+        return false;
+    if (isNode(left, 'Identifier'))
+        return stateVars.has(String(left.name || ''));
+    const root = rootIdentifierName(left);
+    return root ? stateVars.has(root) : false;
+}
+function isAssignmentOperator(op) {
+    return op === '=' || op === '+=' || op === '-=' || op === '*=' || op === '/=' ||
+        op === '%=' || op === '|=' || op === '&=' || op === '^=' || op === '<<=' || op === '>>=';
+}
+function rootIdentifierName(node) {
+    let cur = node;
+    while (cur && typeof cur === 'object') {
+        if (isNode(cur, 'Identifier'))
+            return String(cur.name || '');
+        if (isNode(cur, 'IndexAccess')) {
+            cur = cur.base ?? cur.baseExpression;
+            continue;
+        }
+        if (isNode(cur, 'MemberAccess')) {
+            cur = cur.expression;
+            continue;
+        }
+        return '';
+    }
+    return '';
+}
+function isBalanceOfCall(node) {
+    if (!isFunctionCall(node))
+        return false;
+    const callee = unwrapCallOptions(getCallee(node));
+    if (!isMemberAccess(callee))
+        return false;
+    return String(callee.memberName || '') === 'balanceOf';
+}
+function isExternalTransferCall(node) {
+    if (!isFunctionCall(node))
+        return false;
+    const callee = unwrapCallOptions(getCallee(node));
+    if (!isMemberAccess(callee))
+        return false;
+    const member = String(callee.memberName || '');
+    if (member !== 'transfer' && member !== 'transferFrom' && member !== 'safeTransfer')
+        return false;
+    const args = getCallArguments(node);
+    return args.length >= 2;
+}
+function unwrapAddressCast(expr) {
+    if (!isFunctionCall(expr))
+        return expr;
+    const callee = getCallee(expr);
+    const args = getCallArguments(expr);
+    if (args.length !== 1)
+        return expr;
+    if (isNode(callee, 'ElementaryTypeNameExpression')) {
+        const tn = callee.typeName;
+        const isAddress = (tn?.name === 'address') ||
+            (tn?.typeDescriptions?.typeString === 'address') ||
+            (typeof tn === 'string' && tn === 'address');
+        if (isAddress)
+            return args[0];
+    }
+    if (isNode(callee, 'Identifier') && String(callee.name || '') === 'address') {
+        return args[0];
+    }
+    return expr;
+}
+function unwrapInterfaceCast(expr) {
+    if (!isFunctionCall(expr))
+        return expr;
+    const callee = getCallee(expr);
+    const args = getCallArguments(expr);
+    if (args.length !== 1)
+        return expr;
+    if (!isNode(args[0], 'Identifier'))
+        return expr;
+    if (isNode(callee, 'Identifier') || isNode(callee, 'UserDefinedTypeName')) {
+        return args[0];
+    }
+    return expr;
+}
+function identifierName(node) {
+    if (!node)
+        return '';
+    if (isNode(node, 'Identifier'))
+        return String(node.name || '');
+    return '';
+}
+function isFunctionCall(node) {
+    return isNode(node, 'FunctionCall');
+}
+function isMemberAccess(node) {
+    return isNode(node, 'MemberAccess');
+}
+function getCallee(node) {
+    return node?.expression ?? null;
+}
+function getMemberAccessBase(node) {
+    if (!isMemberAccess(node))
+        return null;
+    return node.expression ?? null;
+}
+function getCallArguments(call) {
+    if (Array.isArray(call?.arguments))
+        return call.arguments;
+    if (Array.isArray(call?.args))
+        return call.args;
+    return [];
+}
+function unwrapCallOptions(expr) {
+    let cur = expr;
+    while (cur && (isNode(cur, 'NameValueExpression') || isNode(cur, 'FunctionCallOptions'))) {
+        cur = cur.expression;
+    }
+    return cur;
+}
+function getBinLeft(node) {
+    return node.left ?? node.leftExpression ?? node.leftHandSide ?? null;
+}
+function getBinRight(node) {
+    return node.right ?? node.rightExpression ?? node.rightHandSide ?? null;
+}
+function hasAccessControlGuard(fn, body) {
+    if ((0, access_control_1.hasRecognisedAccessControlModifier)(fn))
+        return true;
+    for (const m of fn?.modifiers || []) {
+        const name = getModifierName(m).toLowerCase();
+        if (name && ACCESS_CONTROL_MODIFIERS.has(name))
+            return true;
+    }
+    if (body && bodyHasAccessControlRequire(body))
+        return true;
+    return false;
+}
+function bodyHasAccessControlRequire(body) {
+    return walkAny(body, node => {
+        if (!isFunctionCall(node))
+            return false;
+        const calleeName = getCallName(getCallee(node)).toLowerCase();
+        if (calleeName !== 'require' && calleeName !== 'assert')
+            return false;
+        const args = getCallArguments(node);
+        if (args.length === 0)
+            return false;
+        return (0, access_control_1.requireExpressesAccessControl)(args[0], name => (0, access_control_1.isPrivilegedIdentifier)(name));
+    });
+}
+function hasReentrancyGuard(fn) {
+    for (const m of fn?.modifiers || []) {
+        const name = getModifierName(m).toLowerCase();
+        if (!name)
+            continue;
+        if (REENTRANCY_GUARD_MODIFIERS.has(name))
+            return true;
+    }
+    return false;
+}
+function getModifierName(modifier) {
+    if (!modifier)
+        return '';
+    if (typeof modifier === 'string')
+        return modifier;
+    if (typeof modifier.name === 'string')
+        return modifier.name;
+    if (modifier.name && typeof modifier.name === 'object') {
+        if (typeof modifier.name.name === 'string')
+            return modifier.name.name;
+        if (typeof modifier.name.namePath === 'string')
+            return modifier.name.namePath;
+    }
+    if (modifier.modifierName) {
+        const inner = modifier.modifierName;
+        if (typeof inner === 'string')
+            return inner;
+        if (inner && typeof inner.name === 'string')
+            return inner.name;
+    }
+    return '';
+}
+function collectStateVariableNames(contract) {
+    const out = new Set();
+    for (const member of getContractMembers(contract)) {
+        if (isNode(member, 'StateVariableDeclaration')) {
+            for (const variable of member.variables || []) {
+                if (variable?.name)
+                    out.add(String(variable.name));
+            }
+        }
+        else if (isNode(member, 'VariableDeclaration') && member.stateVariable === true) {
+            if (member.name)
+                out.add(String(member.name));
+        }
+    }
+    return out;
+}
+function isAddressParameter(param) {
+    const typeName = param?.typeName;
+    if (!typeName) {
+        const typeString = String(param?.typeDescriptions?.typeString || '');
+        return /^address\b/.test(typeString);
+    }
+    if (typeof typeName === 'string')
+        return typeName === 'address';
+    if (typeName.type === 'ElementaryTypeName' && typeName.name === 'address')
+        return true;
+    if (typeName.nodeType === 'ElementaryTypeName' && typeName.name === 'address')
+        return true;
+    if (typeName.typeDescriptions?.typeString === 'address')
+        return true;
+    return false;
+}
+function isExternallyReachable(fn) {
+    if (!fn)
+        return false;
+    if (fn.isConstructor === true)
+        return false;
+    const kind = String(fn.kind || '').toLowerCase();
+    if (kind === 'constructor')
+        return false;
+    const visibility = String(fn.visibility || '').toLowerCase();
+    if (visibility === 'public' || visibility === 'external')
+        return true;
+    if (kind === 'fallback' || kind === 'receive')
+        return true;
+    return false;
+}
+function isInterfaceLike(contract) {
+    const kind = String(contract?.kind || contract?.contractKind || '').toLowerCase();
+    return kind === 'interface' || kind === 'library';
+}
+function getFunctionBody(fn) {
+    return fn?.body || null;
+}
+function getName(node) {
+    return typeof node?.name === 'string' ? node.name : '';
+}
+function getParameters(fn) {
+    if (Array.isArray(fn?.parameters))
+        return fn.parameters;
+    if (Array.isArray(fn?.parameters?.parameters))
+        return fn.parameters.parameters;
+    return [];
+}
+function getContractFunctions(contract) {
+    return getContractMembers(contract).filter(node => isNode(node, 'FunctionDefinition'));
+}
+function getContractMembers(contract) {
+    if (!contract || typeof contract !== 'object')
+        return [];
+    if (Array.isArray(contract.subNodes))
+        return contract.subNodes;
+    if (Array.isArray(contract.nodes))
+        return contract.nodes;
+    return [];
+}
+function collectContracts(ast) {
+    const out = [];
+    walkContracts(ast, out);
+    return out;
+}
+function walkContracts(node, out) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (isNode(node, 'ContractDefinition')) {
+        out.push(node);
+        return;
+    }
+    for (const child of childrenOf(node))
+        walkContracts(child, out);
+}
+function walkAny(node, predicate) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (predicate(node))
+        return true;
+    for (const child of childrenOf(node)) {
+        if (walkAny(child, predicate))
+            return true;
+    }
+    return false;
+}
+function childrenOf(node) {
+    if (!node || typeof node !== 'object')
+        return [];
+    const out = [];
+    for (const [key, value] of Object.entries(node)) {
+        if (key === 'loc' || key === 'src' || key === 'range' || key === 'typeDescriptions' ||
+            key === 'id' || key === 'scope')
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                if (item && typeof item === 'object')
+                    out.push(item);
+        }
+        else if (value && typeof value === 'object') {
+            out.push(value);
+        }
+    }
+    return out;
+}
+function isNode(node, kind) {
+    return node?.type === kind || node?.nodeType === kind;
+}
+function buildLineOffsets(sourceText) {
+    if (sourceText === undefined)
+        return undefined;
+    const offsets = [0];
+    let byteOffset = 0;
+    for (const ch of sourceText) {
+        byteOffset += Buffer.byteLength(ch, 'utf8');
+        if (ch === '\n')
+            offsets.push(byteOffset);
+    }
+    return offsets;
+}
+function getLoc(node, lineOffsets) {
+    if (node?.loc?.start) {
+        return { line: node.loc.start.line || 0, column: node.loc.start.column || 0 };
+    }
+    if (!node?.src || !lineOffsets)
+        return undefined;
+    const [offsetRaw] = String(node.src).split(':');
+    const offset = Number(offsetRaw);
+    if (!Number.isFinite(offset) || offset < 0)
+        return undefined;
+    return byteOffsetToLineColumn(offset, lineOffsets);
+}
+function byteOffsetToLineColumn(byteOffset, lineOffsets) {
+    let low = 0;
+    let high = lineOffsets.length - 1;
+    let lineIdx = 0;
+    while (low <= high) {
+        const mid = Math.floor((low + high) / 2);
+        if (lineOffsets[mid] <= byteOffset) {
+            lineIdx = mid;
+            low = mid + 1;
+        }
+        else {
+            high = mid - 1;
+        }
+    }
+    return { line: lineIdx + 1, column: byteOffset - lineOffsets[lineIdx] };
+}
+//# sourceMappingURL=skim-token-balance.js.map