Update index.ts

woof-software · MishaShWoof · Aug 9, 2024 · Aug 12, 2024 · Aug 12, 2024 · Aug 12, 2024
commit 53f15136dc4f037c63bfe5eeabe917327fade461
diff --git a/scenario/utils/index.ts b/scenario/utils/index.ts
@@ -19,7 +19,7 @@ import { isBridgeProposal } from './isBridgeProposal';
 
 export { mineBlocks, setNextBaseFeeToZero, setNextBlockTimestamp };
 
-export const MAX_ASSETS = 15;
+export const MAX_ASSETS = 30;
 export const UINT256_MAX = 2n ** 256n - 1n;
 
 export interface ComparativeAmount {

diff --git a/contracts/AssetList.sol b/contracts/AssetList.sol
    /// @notice The number of assets this contract actually supports
    uint8 public immutable numAssets;
    
    constructor(CometConfiguration.AssetConfig[] memory assetConfigs) {
        uint8 _numAssets = uint8(assetConfigs.length);
        numAssets = _numAssets;
        uint256[] memory _assets_a = new uint256[](_numAssets);
        uint256[] memory _assets_b = new uint256[](_numAssets);
        for (uint i = 0; i < _numAssets; )  {
            (uint256 asset_a, uint256 asset_b) = getPackedAssetInternal(assetConfigs, i);
            _assets_a[i] = asset_a;
            _assets_b[i] = asset_b;
            unchecked { i++; }
        }
        assets_a = _assets_a;
        assets_b = _assets_b;
    }

    /**
     * @dev Checks and gets the packed asset info for storage
    function getPackedAssetInternal(CometConfiguration.AssetConfig[] memory assetConfigs, uint i) internal view returns (uint256, uint256) {
        CometConfiguration.AssetConfig memory assetConfig;
        if (i < assetConfigs.length) {
            assembly {
                assetConfig := mload(add(add(assetConfigs, 0x20), mul(i, 0x20)))
            }
        } else {
diff --git a/contracts/CometExtendedAssetList.sol b/contracts/CometExtendedAssetList.sol
    function nonReentrantBefore() internal {
        bytes32 slot = REENTRANCY_GUARD_FLAG_SLOT;
        uint256 status;
        assembly ("memory-safe") {
            status := sload(slot)
        }

        if (status == REENTRANCY_GUARD_ENTERED) revert ReentrantCallBlocked();
        assembly ("memory-safe") {
            sstore(slot, REENTRANCY_GUARD_ENTERED)
        }
    }
     */
    function nonReentrantAfter() internal {
        bytes32 slot = REENTRANCY_GUARD_FLAG_SLOT;
        uint256 status;
        assembly ("memory-safe") {
            sstore(slot, REENTRANCY_GUARD_NOT_ENTERED)
        }
    }
        uint256 preTransferBalance = IERC20NonStandard(asset).balanceOf(address(this));
        IERC20NonStandard(asset).transferFrom(from, address(this), amount);
        bool success;
        assembly ("memory-safe") {
            switch returndatasize()
                case 0 {                       // This is a non-standard ERC-20
                    success := not(0)          // set success to true
    function doTransferOut(address asset, address to, uint amount) internal {
        IERC20NonStandard(asset).transfer(to, amount);
        bool success;
        assembly ("memory-safe") {
            switch returndatasize()
                case 0 {                       // This is a non-standard ERC-20
                    success := not(0)          // set success to true

        uint startGas = gasleft();
        accrueInternal();
        for (uint i = 0; i < accounts.length; ) {
            absorbInternal(absorber, accounts[i]);
            unchecked { i++; }
        }
        uint gasUsed = startGas - gasleft();

        // Using gas price instead of base fee would more accurately reflect spend,
        //  but is also subject to abuse if refunds were to be given automatically.
        LiquidatorPoints memory points = liquidatorPoints[absorber];
        points.numAbsorbs++;
        points.numAbsorbed += safe64(accounts.length);
        points.approxSpend += safe128(gasUsed * block.basefee);
        liquidatorPoints[absorber] = points;
        uint16 assetsIn = accountUser.assetsIn;

        uint256 basePrice = getPrice(baseTokenPriceFeed);
        uint256 deltaValue = 0;

        for (uint8 i = 0; i < numAssets; ) {
            if (isInAsset(assetsIn, i)) {

                emit AbsorbCollateral(absorber, account, asset, seizeAmount, value);
            }
            unchecked { i++; }
        }

        uint256 deltaBalance = divPrice(deltaValue, basePrice, uint64(baseScale));
        if (isBuyPaused()) revert Paused();

        int reserves = getReserves();
        if (reserves >= 0 && uint(reserves) >= targetReserves) revert NotForSale();

        // Note: Re-entrancy can skip the reserves check above on a second buyCollateral call.
        baseAmount = doTransferIn(baseToken, msg.sender, baseAmount);
    /**
     * @notice Fallback to calling the extension delegate for everything else
     */
    fallback() external payable {
        address delegate = extensionDelegate;
        assembly {
            calldatacopy(0, 0, calldatasize())
            let result := delegatecall(gas(), delegate, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
	/// @notice The number of assets this contract actually supports
	uint8 public immutable numAssets;

	constructor(CometConfiguration.AssetConfig[] memory assetConfigs) {
	uint8 _numAssets = uint8(assetConfigs.length);
	numAssets = _numAssets;
	uint256[] memory _assets_a = new uint256[](_numAssets);
	uint256[] memory _assets_b = new uint256[](_numAssets);
	for (uint i = 0; i < _numAssets; ) {
	(uint256 asset_a, uint256 asset_b) = getPackedAssetInternal(assetConfigs, i);
	_assets_a[i] = asset_a;
	_assets_b[i] = asset_b;
	unchecked { i++; }
Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.use-prefix-increment-not-postfix Note Consider using the prefix increment expression whenever the return value is not needed. The prefix increment expression is cheaper in terms of gas.
	}
	assets_a = _assets_a;
	assets_b = _assets_b;
	}
Check warning Code scanning / Semgrep OSS Semgrep Finding: compound.solidity.missing-constructor-sanity-checks Warning There're no sanity checks for the constructor argument assetConfigs. Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.non-payable-constructor Note Consider making costructor payable to save gas.

	/**
	* @dev Checks and gets the packed asset info for storage
	function getPackedAssetInternal(CometConfiguration.AssetConfig[] memory assetConfigs, uint i) internal view returns (uint256, uint256) {
	CometConfiguration.AssetConfig memory assetConfig;
	if (i < assetConfigs.length) {
	assembly {
Check warning on line 51 in contracts/AssetList.sol GitHub Actions / Contract linter `Avoid to use inline assembly. It is acceptable only in rare cases`
	assetConfig := mload(add(add(assetConfigs, 0x20), mul(i, 0x20)))
	}
	} else {
	function nonReentrantBefore() internal {
	bytes32 slot = REENTRANCY_GUARD_FLAG_SLOT;
	uint256 status;
	assembly ("memory-safe") {
Check warning on line 179 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Avoid to use inline assembly. It is acceptable only in rare cases`
	status := sload(slot)
	}

	if (status == REENTRANCY_GUARD_ENTERED) revert ReentrantCallBlocked();
	assembly ("memory-safe") {
Check warning on line 184 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Avoid to use inline assembly. It is acceptable only in rare cases`
	sstore(slot, REENTRANCY_GUARD_ENTERED)
	}
	}
	*/
	function nonReentrantAfter() internal {
	bytes32 slot = REENTRANCY_GUARD_FLAG_SLOT;
	uint256 status;
Check warning on line 194 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Variable "status" is unused`
	assembly ("memory-safe") {
Check warning on line 195 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Avoid to use inline assembly. It is acceptable only in rare cases`
	sstore(slot, REENTRANCY_GUARD_NOT_ENTERED)
	}
	}
	uint256 preTransferBalance = IERC20NonStandard(asset).balanceOf(address(this));
	IERC20NonStandard(asset).transferFrom(from, address(this), amount);
	bool success;
	assembly ("memory-safe") {
Check warning on line 638 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Avoid to use inline assembly. It is acceptable only in rare cases`
	switch returndatasize()
	case 0 { // This is a non-standard ERC-20
	success := not(0) // set success to true
	function doTransferOut(address asset, address to, uint amount) internal {
	IERC20NonStandard(asset).transfer(to, amount);
	bool success;
	assembly ("memory-safe") {
Check warning on line 662 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Avoid to use inline assembly. It is acceptable only in rare cases`
	switch returndatasize()
	case 0 { // This is a non-standard ERC-20
	success := not(0) // set success to true

	uint startGas = gasleft();
	accrueInternal();
	for (uint i = 0; i < accounts.length; ) {
Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.array-length-outside-loop Note Caching the array length outside a loop saves reading it on each iteration, as long as the array's length is not changed during the loop.
	absorbInternal(absorber, accounts[i]);
	unchecked { i++; }
Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.use-prefix-increment-not-postfix Note Consider using the prefix increment expression whenever the return value is not needed. The prefix increment expression is cheaper in terms of gas.
	}
	uint gasUsed = startGas - gasleft();

	// Using gas price instead of base fee would more accurately reflect spend,
	// but is also subject to abuse if refunds were to be given automatically.
	LiquidatorPoints memory points = liquidatorPoints[absorber];
	points.numAbsorbs++;
Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.use-prefix-increment-not-postfix Note Consider using the prefix increment expression whenever the return value is not needed. The prefix increment expression is cheaper in terms of gas.
	points.numAbsorbed += safe64(accounts.length);
	points.approxSpend += safe128(gasUsed * block.basefee);
	liquidatorPoints[absorber] = points;
	uint16 assetsIn = accountUser.assetsIn;

	uint256 basePrice = getPrice(baseTokenPriceFeed);
	uint256 deltaValue = 0;
Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.init-variables-with-default-value Note Uninitialized variables are assigned with the types default value. Explicitly initializing a variable with its default value costs unnecessary gas.

	for (uint8 i = 0; i < numAssets; ) {
	if (isInAsset(assetsIn, i)) {

	emit AbsorbCollateral(absorber, account, asset, seizeAmount, value);
	}
	unchecked { i++; }
Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.use-prefix-increment-not-postfix Note Consider using the prefix increment expression whenever the return value is not needed. The prefix increment expression is cheaper in terms of gas.
	}

	uint256 deltaBalance = divPrice(deltaValue, basePrice, uint64(baseScale));
	if (isBuyPaused()) revert Paused();

	int reserves = getReserves();
	if (reserves >= 0 && uint(reserves) >= targetReserves) revert NotForSale();
Check notice Code scanning / Semgrep OSS Semgrep Finding: rules.solidity.performance.use-nested-if Note Using nested is cheaper than using && multiple check combinations. There are more advantages, such as easier to read code and better coverage reports.

	// Note: Re-entrancy can skip the reserves check above on a second buyCollateral call.
	baseAmount = doTransferIn(baseToken, msg.sender, baseAmount);
	/**
	* @notice Fallback to calling the extension delegate for everything else
	*/
	fallback() external payable {
Check warning on line 1215 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Fallback function must be simple`
	address delegate = extensionDelegate;
	assembly {
Check warning on line 1217 in contracts/CometExtendedAssetList.sol GitHub Actions / Contract linter `Avoid to use inline assembly. It is acceptable only in rare cases`
	calldatacopy(0, 0, calldatasize())
	let result := delegatecall(gas(), delegate, 0, calldatasize(), 0, 0)
	returndatacopy(0, 0, returndatasize())