VegaSec / Solidity scan report

arithmetic-bectoken.sol

VSS-20261003-OX80LH19 · generated Oct 3, 2026, 7:53 PM

Strong surface · automated17 findings1 highPasted source1 warningsemgrep 1.163.0

Verdict is derived from severity counts via the same deterministic formula every VegaSec report uses. arithmetic-bectoken.sol was scanned from pasted source. This is static-analysis triage, not a certification or formal audit attestation.

Signature

signed

This report is signed. Anyone can verify that these exact bytes came from us, with no account, no wallet and no API key. The signature proves integrity and authorship. It does not prove the audited contract is safe: read the coverage status and the limitations above.

sha256
614940d4bf07c244...0b89ad50
Signed by
Ed25519 key vsig-2026-09
Canonical version
vss-canonical-1
Bytes served
stored canonical text, byte for byte

PDF artifact

Queued artifact pipeline · not blocking on the scan

Not requested

No PDF artifact has been requested for this report yet. The HTML report and the Markdown export already carry the full disclaimer and limitations inline. PDF synthesis is a queued artifact, not part of the scan path.

Status endpoint

GET /report/solidity/VSS-20261003-OX80LH19/export.pdf

Solidity evidence report

17 audit findings

critical: 0high: 1medium: 0low: 0informational: 16

Severity distribution

Executive summary

  • 17 findings surfaced (0 critical, 1 high, 0 medium, 0 low, 16 informational).
  • HIGH · Batch helper multiplies a count derived from a dynamic array by a caller-supplied amount and stores the product without a bounds check — exploitability medium.
  • Automated static analysis only. A human operator review has not been attached to this report.

Warnings (1)

  • · Unmapped detector slither:too-many-digits — classified as 'other'
semgrep 1.163.0
  • highMath / overflowConfidence: mediumExploitability: mediumDetector: semgrep

    Batch helper multiplies a count derived from a dynamic array by a caller-supplied amount and stores the product without a bounds check

    Affected location
    arithmetic-bectoken.sol:7-264
    Detector / source
    semgrep · semgrep:vegasec-unchecked-arithmetic-batch-multiply

    Evidence

    Batch helper multiplies a count derived from a dynamic array by a caller-supplied amount and stores the product without a bounds check. On Solidity < 0.8 the multiply wraps silently (SWC-101 / batchOverflow class): a huge amount overflows to a small total, passes the balance check and credits every receiver. Use SafeMath/.mul, require the product to fit, or move to Solidity >= 0.8 checked arithmetic.

    Exploitability notes

    Medium-confidence detection; manual review required before relying on the finding either way.

    Remediation

    Confirm the solc version uses checked arithmetic (>=0.8) or wrap mutations in OpenZeppelin SafeMath. Avoid unchecked blocks unless explicitly justified.

    Limitations

    • Medium analyzer confidence; manual review should confirm the code path and preconditions.
    • Exploitability depends on deployment context, permissions, balances, and reachable preconditions.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Version constraint ^0.4.16 contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html)

    Affected location
    arithmetic-bectoken.sol:7 · ^0.4.16
    Detector / source
    slither · slither:solc-version

    Evidence

    Version constraint ^0.4.16 contains known severe issues (https://solidity.readthedocs.io/en/latest/bugs.html) - DirtyBytesArrayToStorage - ABIDecodeTwoDimensionalArrayMemory - KeccakCaching - EmptyByteArrayCopy - DynamicArrayCleanup - ImplicitConstructorCallvalueCheck - TupleAssignmentMultiStackSlotComponents - MemoryArrayCreationOverflow - privateCanBeOverridden - SignedArrayStorageCopy - ABIEncoderV2StorageArrayWithMultiSlotElement - DynamicConstructorArgumentsClippedABIV2 - UninitializedFunctionPointerInConstructor_0.4.x - IncorrectEventSignatureInLibraries_0.4.x - ExpExponentCleanup - NestedArrayFunctionCallDecoder - ZeroFunctionSelector. It is used by: - ^0.4.16 (arithmetic-bectoken.sol#7)

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter BasicToken.transfer(address,uint256)._value (arithmetic-bectoken.sol#65) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:65 · _value
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter BasicToken.transfer(address,uint256)._value (arithmetic-bectoken.sol#65) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter BasicToken.balanceOf(address)._owner (arithmetic-bectoken.sol#81) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:81 · _owner
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter BasicToken.balanceOf(address)._owner (arithmetic-bectoken.sol#81) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter StandardToken.transferFrom(address,address,uint256)._from (arithmetic-bectoken.sol#116) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:116 · _from
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter StandardToken.transferFrom(address,address,uint256)._from (arithmetic-bectoken.sol#116) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter StandardToken.approve(address,uint256)._value (arithmetic-bectoken.sol#138) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:138 · _value
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter StandardToken.approve(address,uint256)._value (arithmetic-bectoken.sol#138) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter StandardToken.allowance(address,address)._spender (arithmetic-bectoken.sol#150) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:150 · _spender
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter StandardToken.allowance(address,address)._spender (arithmetic-bectoken.sol#150) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter PausableToken.transfer(address,uint256)._value (arithmetic-bectoken.sol#249) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:249 · _value
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter PausableToken.transfer(address,uint256)._value (arithmetic-bectoken.sol#249) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter PausableToken.transferFrom(address,address,uint256)._from (arithmetic-bectoken.sol#253) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:253 · _from
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter PausableToken.transferFrom(address,address,uint256)._from (arithmetic-bectoken.sol#253) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter PausableToken.approve(address,uint256)._spender (arithmetic-bectoken.sol#257) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:257 · _spender
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter PausableToken.approve(address,uint256)._spender (arithmetic-bectoken.sol#257) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    batchTransfer(address[],uint256) should be declared external:

    Affected location
    arithmetic-bectoken.sol:261-274 · batchTransfer
    Detector / source
    slither · slither:external-function

    Evidence

    batchTransfer(address[],uint256) should be declared external: - PausableToken.batchTransfer(address[],uint256) (arithmetic-bectoken.sol#261-274)

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    Parameter PausableToken.batchTransfer(address[],uint256)._receivers (arithmetic-bectoken.sol#261) is not in mixedCase

    Affected location
    arithmetic-bectoken.sol:261 · _receivers
    Detector / source
    slither · slither:naming-convention

    Evidence

    Parameter PausableToken.batchTransfer(address[],uint256)._receivers (arithmetic-bectoken.sol#261) is not in mixedCase

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    BecToken.name (arithmetic-bectoken.sol#289) should be constant

    Affected location
    arithmetic-bectoken.sol:289 · name
    Detector / source
    slither · slither:constable-states

    Evidence

    BecToken.name (arithmetic-bectoken.sol#289) should be constant

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    BecToken.symbol (arithmetic-bectoken.sol#290) should be constant

    Affected location
    arithmetic-bectoken.sol:290 · symbol
    Detector / source
    slither · slither:constable-states

    Evidence

    BecToken.symbol (arithmetic-bectoken.sol#290) should be constant

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    BecToken.version (arithmetic-bectoken.sol#291) should be constant

    Affected location
    arithmetic-bectoken.sol:291 · version
    Detector / source
    slither · slither:constable-states

    Evidence

    BecToken.version (arithmetic-bectoken.sol#291) should be constant

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalLogicConfidence: highExploitability: lowDetector: slither

    BecToken.decimals (arithmetic-bectoken.sol#292) should be constant

    Affected location
    arithmetic-bectoken.sol:292 · decimals
    Detector / source
    slither · slither:constable-states

    Evidence

    BecToken.decimals (arithmetic-bectoken.sol#292) should be constant

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Re-derive the business rule by hand, write a property-based test that fails on the current path, and only then fix the implementation.

    Limitations

    • High analyzer confidence, still requires source-level review before promotion.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.
  • informationalOtherConfidence: mediumExploitability: lowDetector: slither

    BecToken.BecToken() (arithmetic-bectoken.sol#297-300) uses literals with too many digits:

    Affected location
    arithmetic-bectoken.sol:297-300 · BecToken
    Detector / source
    slither · slither:too-many-digits

    Evidence

    BecToken.BecToken() (arithmetic-bectoken.sol#297-300) uses literals with too many digits: - totalSupply = 7000000000 * (10 ** (uint256(decimals))) (arithmetic-bectoken.sol#298)

    Exploitability notes

    Informational signal; not directly exploitable without additional context.

    Remediation

    Review the detector output against the source manually; if exploitable, design a fix and add a regression test before deploying.

    Limitations

    • Medium analyzer confidence; manual review should confirm the code path and preconditions.
    • Direct exploitability is not established; keep the signal as a remediation/checklist item.
    • Analyzer output did not include a source excerpt for this finding.

Limitations

  • VegaSec runs static analysis only. Findings can include false positives, miss patterns the configured detectors do not cover, and never replace manual auditor judgement.
  • Scan ran slither and semgrep against a single sandboxed copy of the source. Multi-file dependency analysis beyond what slither resolves automatically is out of scope.
  • Some detectors emitted warnings (see `warnings`); their output was still ingested but should be read with extra care.
  • This report is not a certification, audit attestation, or financial advice.

Exploit reasoning

Reference-grade reasoning tied to evidence

  • d7260e05a127d4f97d5b54826e692574c382409b9e94474b8ed37a9645630369 · math-overflowhigh
    Confidence: low

    Conditions point at the exploit but at least one precondition needs operator confirmation.

    Preconditions

    • Arithmetic outside Solidity 0.8+ overflow checks (assembly, unchecked block, or compiler < 0.8)
    • Caller-controlled inputs reach the arithmetic without bounds checks

    Action

    Attacker passes inputs that wrap a balance or counter past its boundary, producing values that pass downstream checks.

    Impact

    Inflated balances, bypass of cap checks, or denial-of-service when iteration counters wrap.

    False-positive caveats

    • Unchecked blocks are sometimes intentional (gas optimization on values bounded by other invariants).
    • Compiler ≥ 0.8.0 reverts on overflow unless the code explicitly opts out.

    Remediation checklist

    • Move arithmetic out of the unchecked block.
    • Bound caller inputs with explicit require() before arithmetic.
    • Upgrade compiler to ≥ 0.8.0 when feasible and remove SafeMath wrappers.

Audit pipeline

Audit cockpit

Honest stage-by-stage view of what VegaSec ran against this contract. Automated stages do not replace a human operator review.

Passed: 3Partial: 5Blocked: 1
  1. Audit intake

    Passed320ms replay7:53 PM

    Normalize the submitted contract target and confirm it can enter the Solidity audit lane.

    Next: Acquire verified source or scan the pasted Solidity source.

  2. Source acquisition

    Passed1.4s replay7:53 PM

    Resolve pasted source or verified explorer source without treating malformed input as demo data.

    Next: Validate the analyzer toolchain against the acquired source.

  3. Toolchain validation

    Partial2.3s replay7:53 PM

    Confirm the configured static analyzers can run and produce parseable output.

    Next: Run static analysis and capture raw detector evidence.

    • One or more analyzers emitted warnings; report findings remain usable but should be read with limitations.
  4. Static analysis

    Partial17 findings8.8s replay7:53 PM

    Run static analyzers against the sandboxed source and collect raw detector evidence.

    Next: Normalize detector output into one deduped finding set.

    • One or more analyzers emitted warnings; report findings remain usable but should be read with limitations.
  5. Finding normalization

    Passed17 findings1.1s replay7:53 PM

    Dedupe detectors, classify vulnerability classes and compute severity-weighted risk.

    Next: Review exploitability conservatively against confidence and limitations.

  6. Exploitability review

    Partial17 findings1.9s replay7:53 PM

    Frame automated findings with conservative exploitability and limitation notes.

    Next: Draft remediation notes from the normalized evidence.

    • Automated exploitability review is conservative and does not replace a manual exploitability assessment.
  7. Remediation draft

    Partial17 findings1.5s replay7:53 PM

    Prepare remediation-oriented evidence for the shareable report artifact.

    Next: Attach an operator review artifact before claiming human review.

    • Remediation notes are generated from detector evidence and require project-specific engineering review.
  8. Operator review

    Blocked0ms replay7:53 PM

    Record whether a human operator artifact exists before buyer escalation.

    Next: Attach a real operator review artifact before claiming human review.

    • No operator review artifact is attached to this automated scan.
    • Human operator review has not been attached to this automated scan yet.
  9. Finalization

    Partial17 findings620ms replay7:53 PM

    Publish the automated report artifact or explain why the scan failed closed.

    Next: Share the report with explicit limitations and review state.

    Artifact: Automated Solidity report · solidity-2f746d702f766567

    • Final report is an automated static-analysis artifact; no operator review artifact is attached.

Report badges

Verified source

Badges describe the evidence carried by this report artifact, not financial value or future pricing. Operator-reviewed is never granted automatically.

How to read this report

Score, confidence, ranking: four moving parts, no hand-tuning.

Generated Oct 3, 2026, 7:53 PM · Solidity · arithmetic-bectoken.sol

Score bands

  • 0-19

    AVOID-style triage

    Multiple high or critical findings, low source confidence, or unverified context. Public action should pause until a Private Review or a re-scan with better evidence.

  • 20-49

    High caution

    Notable findings or thin evidence. Worth a Private Review before relying on the artifact.

  • 50-69

    Watch

    Mixed signals: some evidence, some gaps. Re-scan after material changes to the target.

  • 70-89

    Clear surface (automated)

    No critical or high findings via static analysis. Not a safety claim: human review is still recommended for diligence work.

  • 90-100

    Strong surface (automated) · this report

    No critical or high findings, verified source, and high source confidence. Not a safety claim: human review is still recommended for diligence work.

Score
Deterministic 0-100 derived from severity counts. Same formula across every report. Lower means more risk.
Confidence
Separate axis. Measures how much VegaSec trusts the input data. Low confidence pushes the verdict toward UNKNOWN; the two are never collapsed into one number.
Ranking / percentile
Only meaningful within the eligible Trust Index set. Shown on /trust-index when the eligible pool is large enough. Today the public index is a controlled preview.

Private Review is separate

A paid Private Review does not raise the public score on this report. Public score reflects public-source evidence only. Private Review adds operator attestation and a confidential memo, never a score bump.

Export and share

  • · Shareable public URL: copy from the report actions panel.
  • · Markdown export: every export carries the report id, target, verdict, generated timestamp, and the public-data disclaimer.
  • · PDF export: not in this MVP. Tracked as a follow-up. The Markdown export contains the same content and prints cleanly to PDF from a browser today.

Source provenance

This report scanned a Solidity source provided directly by the submitter (paste). No on-chain address is associated.

Scanned source (9,214 chars)

/*
 * @source: https://smartcontractsecurity.github.io/SWC-registry/docs/SWC-101#bectokensol
 * @author: -
 * @vulnerable_at_lines: 264
 */

pragma solidity ^0.4.16;

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a * b;
    require(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal constant returns (uint256) {
    // require(b > 0); // Solidity automatically throws when dividing by 0
    uint256 c = a / b;
    // require(a == b * c + a % b); // There is no case in which this doesn't hold
    return c;
  }

  function sub(uint256 a, uint256 b) internal constant returns (uint256) {
    require(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal constant returns (uint256) {
    uint256 c = a + b;
    require(c >= a);
    return c;
  }
}

/**
 * @title ERC20Basic
 * @dev Simpler version of ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/179
 */
contract ERC20Basic {
  uint256 public totalSupply;
  function balanceOf(address who) public constant returns (uint256);
  function transfer(address to, uint256 value) public returns (bool);
  event Transfer(address indexed from, address indexed to, uint256 value);
}

/**
 * @title Basic token
 * @dev Basic version of StandardToken, with no allowances.
 */
contract BasicToken is ERC20Basic {
  using SafeMath for uint256;

  mapping(address => uint256) balances;

  /**
  * @dev transfer token for a specified address
  * @param _to The address to transfer to.
  * @param _value The amount to be transferred.
  */
  function transfer(address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value > 0 && _value <= balances[msg.sender]);

    // SafeMath.sub will throw if there is not enough balance.
    balances[msg.sender] = balances[msg.sender].sub(_value);
    balances[_to] = balances[_to].add(_value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  /**
  * @dev Gets the balance of the specified address.
  * @param _owner The address to query the the balance of.
  * @return An uint256 representing the amount owned by the passed address.
  */
  function balanceOf(address _owner) public constant returns (uint256 balance) {
    return balances[_owner];
  }
}

/**
 * @title ERC20 interface
 * @dev see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 is ERC20Basic {
  function allowance(address owner, address spender) public constant returns (uint256);
  function transferFrom(address from, address to, uint256 value) public returns (bool);
  function approve(address spender, uint256 value) public returns (bool);
  event Approval(address indexed owner, address indexed spender, uint256 value);
}


/**
 * @title Standard ERC20 token
 *
 * @dev Implementation of the basic standard token.
 * @dev https://github.com/ethereum/EIPs/issues/20
 * @dev Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, BasicToken {

  mapping (address => mapping (address => uint256)) internal allowed;


  /**
   * @dev Transfer tokens from one address to another
   * @param _from address The address which you want to send tokens from
   * @param _to address The address which you want to transfer to
   * @param _value uint256 the amount of tokens to be transferred
   */
  function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    require(_value > 0 && _value <= balances[_from]);
    require(_value <= allowed[_from][msg.sender]);

    balances[_from] = balances[_from].sub(_value);
    balances[_to] = balances[_to].add(_value);
    allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
    Transfer(_from, _to, _value);
    return true;
  }

  /**
   * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
   *
   * Beware that changing an allowance with this method brings the risk that someone may use both the old
   * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
   * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
   * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   * @param _spender The address which will spend the funds.
   * @param _value The amount of tokens to be spent.
   */
  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  /**
   * @dev Function to check the amount of tokens that an owner allowed to a spender.
   * @param _owner address The address which owns the funds.
   * @param _spender address The address which will spend the funds.
   * @return A uint256 specifying the amount of tokens still available for the spender.
   */
  function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
    return allowed[_owner][_spender];
  }
}

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
  address public owner;


  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);


  /**
   * @dev The Ownable constructor sets the original `owner` of the contract to the sender
   * account.
   */
  function Ownable() {
    owner = msg.sender;
  }


  /**
   * @dev Throws if called by any account other than the owner.
   */
  modifier onlyOwner() {
    require(msg.sender == owner);
    _;
  }


  /**
   * @dev Allows the current owner to transfer control of the contract to a newOwner.
   * @param newOwner The address to transfer ownership to.
   */
  function transferOwnership(address newOwner) onlyOwner public {
    require(newOwner != address(0));
    OwnershipTransferred(owner, newOwner);
    owner = newOwner;
  }

}

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is Ownable {
  event Pause();
  event Unpause();

  bool public paused = false;


  /**
   * @dev Modifier to make a function callable only when the contract is not paused.
   */
  modifier whenNotPaused() {
    require(!paused);
    _;
  }

  /**
   * @dev Modifier to make a function callable only when the contract is paused.
   */
  modifier whenPaused() {
    require(paused);
    _;
  }

  /**
   * @dev called by the owner to pause, triggers stopped state
   */
  function pause() onlyOwner whenNotPaused public {
    paused = true;
    Pause();
  }

  /**
   * @dev called by the owner to unpause, returns to normal state
   */
  function unpause() onlyOwner whenPaused public {
    paused = false;
    Unpause();
  }
}

/**
 * @title Pausable token
 *
 * @dev StandardToken modified with pausable transfers.
 **/

contract PausableToken is StandardToken, Pausable {

  function transfer(address _to, uint256 _value) public whenNotPaused returns (bool) {
    return super.transfer(_to, _value);
  }

  function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
    return super.transferFrom(_from, _to, _value);
  }

  function approve(address _spender, uint256 _value) public whenNotPaused returns (bool) {
    return super.approve(_spender, _value);
  }

  function batchTransfer(address[] _receivers, uint256 _value) public whenNotPaused returns (bool) {
    uint cnt = _receivers.length;
    // <yes> <report> ARITHMETIC
    uint256 amount = uint256(cnt) * _value;
    require(cnt > 0 && cnt <= 20);
    require(_value > 0 && balances[msg.sender] >= amount);

    balances[msg.sender] = balances[msg.sender].sub(amount);
    for (uint i = 0; i < cnt; i++) {
        balances[_receivers[i]] = balances[_receivers[i]].add(_value);
        Transfer(msg.sender, _receivers[i], _value);
    }
    return true;
  }
}

/**
 * @title Bec Token
 *
 * @dev Implementation of Bec Token based on the basic standard token.
 */
contract BecToken is PausableToken {
    /**
    * Public variables of the token
    * The following variables are OPTIONAL vanities. One does not have to include them.
    * They allow one to customise the token contract & in no way influences the core functionality.
    * Some wallets/interfaces might not even bother to look at this information.
    */
    string public name = "BeautyChain";
    string public symbol = "BEC";
    string public version = '1.0.0';
    uint8 public decimals = 18;

    /**
     * @dev Function to check the amount of tokens that an owner allowed to a spender.
     */
    function BecToken() {
      totalSupply = 7000000000 * (10**(uint256(decimals)));
      balances[msg.sender] = totalSupply;    // Give the creator all initial tokens
    }

    function () {
        //if ether is sent to this address, send it back.
        revert();
    }
}

Public-data disclaimer

Solidity scans are triage based on slither + semgrep static analysis. Output is not a certification, audit attestation or financial advice. Findings can include false positives and may miss patterns the configured detectors do not cover.