Inkubate - Marketplace

CertiKFiles named in the report

Audit

Part of CertiK’s series

CertiK reviewed SquidGrow (Inkubate - Marketplace) on 26 Jan 2024: 20 findings, 0 critical; none marked fixed.

No open critical findings
Open the reportOpen SquidGrow’s security record

Report hosted on skynet.certik.com.

Trustblock does not review code.

Findings20

Statuses are the security firm’s own, from its report.

SeverityOpenAcknowledgedFixed
Critical000
High000
Medium600
Low1400
MediumBuyer Opts for the Maximum Offerer Might Have InsOpen

The function `validateOfferItemApprovalAndBalance()` verifies that for an ERC1155/ERC20/Native itemType, the offerer's balance exceeds the minBalance. According to the progress of order fulfillment, the final transferred amount of offered items is calculated linearly based on the time elapsed since the order became active. It's noted that the buyer may purchase any quantity between the `startAmount` and `endAmount`. Yet, the offerer's balance must surpass the `maxBalance`, not just the `minBalance`. This is to prevent a scenario where a buyer opts for the maximum amount, but the offerer doesn't have enough balance, leading to a failed transaction. See the function `_locateCurrentAmount` below which is used to derive the current amount of a given item based on the current price: --- File: contracts/lib/AmountDeriver.sol ```solidity=42 function _locateCurrentAmount( uint256 startAmount, uint256 endAmount, uint256 startTime, uint256 endTime, bool roundUp ) internal view returns (uint256 amount) { // Only modify end amount if it doesn't already equal start amount. .... uint256 duration; uint256 elapsed; uint256 remaining; // Skip underflow checks as startTime <= block.timestamp < endTime. unchecked { // Derive the duration for the order and place it on the stack. duration = endTime - startTime; // Derive time elapsed since the order started & place on stack. elapsed = block.timestamp - startTime; // Derive time remaining until order expires and place on stack. remaining = duration - elapsed; } // Aggregate new amounts weighted by time with rounding factor. uint256 totalBeforeDivision = ((startAmount * remaining) + (endAmount * elapsed)); // Use assembly to combine operations and skip divide-by-zero check. assembly { // Multiply by iszero(iszero(totalBeforeDivision)) to ensure // amount is set to zero if totalBeforeDivision is zero, // as intermediate overflow can occur if it is zero. amount := mul( iszero(iszero(totalBeforeDivision)), // Subtract 1 from the numerator and add 1 to the result if // roundUp is true to get the proper rounding direction. // Division is performed with no zero check as duration // cannot be zero as long as startTime < endTime. add( div(sub(totalBeforeDivision, roundUp), duration), roundUp ) ) } // Return the current amount. return amount; .... } ```

MediumInadequate Update Mechanism in `FulfillmentGeneraOpen

In the function `FulfillmentGeneratorLib.consumeMaximumItemsAndGetFulfillment()`, the linked *if* blocks update variables from `offerItems` and `considerationItems` that are not used in the logic of the function. The specific role and impact of these *if* blocks are ambiguous as decreasing operations within the block could theoretically serve as checks — potentially triggering a function failure implicitly in some scenarios. This raises questions about the intended functionality of this block, as some changes made to the input structs do not influence the function's output and are not accompanied by explicit error handling or messaging. ---- In addition to the primary issue in the `FulfillmentGeneratorLib.consumeMaximumItemsAndGetFulfillment()` function, it is important to note that the function `FulfillmentGeneratorLib.getMaxInclusionConsumeMethod()` relies on the output of `FulfillmentGeneratorLib.consumeMaximumItemsAndGetFulfillment()`. The issue not only affects the direct caller but also cascades to other parts of the system where this function is used, potentially leading to widespread inaccuracies or logic flaws.

MediumInadequate Update Mechanism in `FulfillmentGeneraOpen

In the function `FulfillmentGeneratorLib.consumeMinimumItemsAndGetFulfillment()`, the *if* block: ```solidity=725 if (offerItem.amount < considerationItem.amount) { offerItems.totalAmount -= offerItem.amount; considerationItems.totalAmount -= offerItem.amount; considerationItem.amount -= offerItem.amount; offerItem.amount = 0; } else { offerItems.totalAmount -= considerationItem.amount; considerationItems.totalAmount -= considerationItem.amount; offerItem.amount -= considerationItem.amount; considerationItem.amount = 0; } ``` modifies the input parameter structs but does not alter the return values, which are generated earlier in the function. The specific role and impact of this *if* block is ambiguous as decreasing operations within the block could theoretically serve as checks — potentially triggering a function failure implicitly in some scenarios. This raises questions about the intended functionality of this block, as the changes made to the input structs do not influence the function's output and are not accompanied by explicit error handling or messaging. ---- In addition to the primary issue in the `FulfillmentGeneratorLib.consumeMinimumItemsAndGetFulfillment()` function, it is important to note that the function `FulfillmentGeneratorLib.getMaxInclusionConsumeMethod()` relies on the output of `FulfillmentGeneratorLib.consumeMinimumItemsAndGetFulfillment()`. The issue not only affects the direct callers but also cascades to other parts of the system where this function is used, potentially leading to widespread inaccuracies or logic flaws.

MediumInadequate Update Mechanism in `FulfillmentGeneraOpen

In the function `FulfillmentGeneratorLib.consumeRandomItemsAndGetFulfillment()`, the *if* block: ```solidity=992 if (totalOfferAmount > totalConsiderationAmount) { uint256 remainingAmount = (totalOfferAmount - totalConsiderationAmount); // add back excess to first offer item offerItems.items[consumableOfferIndices[0]].amount += ( remainingAmount ); offerItems.totalAmount -= totalConsiderationAmount; considerationItems.totalAmount -= totalConsiderationAmount; } else { uint256 remainingAmount = (totalConsiderationAmount - totalOfferAmount); // add back excess to first consideration item considerationItems .items[consumableConsiderationIndices[0]] .amount += remainingAmount; offerItems.totalAmount -= totalOfferAmount; considerationItems.totalAmount -= totalOfferAmount; } ``` modifies the input parameter structs but does not alter the return values, which are generated earlier in the function. The specific role and impact of this *if* block are ambiguous. While decreasing operations within the block could theoretically serve as checks — potentially triggering a function failure implicitly in some scenarios — other operations, such as incrementing `considerationItems .items[consumableConsiderationIndices[0]] .amount`, does not align with a checking mechanism. This discrepancy raises questions about the intended functionality of this block, as the changes made to the input structs do not influence the function's output and are not accompanied by explicit error handling or messaging. ----- In addition to the primary issue in the `FulfillmentGeneratorLib.consumeRandomItemsAndGetFulfillment()` function, it is important to note that the function `FulfillmentGeneratorLib.getMaxInclusionConsumeMethod()` relies on the output of `FulfillmentGeneratorLib.consumeRandomItemsAndGetFulfillment()`. The issue not only affects the direct callers but also cascades to other parts of the system where this function is used, potentially leading to widespread inaccuracies or logic flaws.

MediumLogical Issue in `FulfillmentLib.bundleByMatchablOpen

In the `FulfillmentLib.bundleByMatchable()` function, the initial operation: ```solidity=1786 ItemReferenceGroup[] memory groups = itemReferences .getUniqueFullHashes() .allocateItemReferenceGroup(); ``` generates the return object `groups`. The following *for* loop: ```solidity=1790 for (uint256 i = 0; i < itemReferences.length; ++i) { ItemReferenceLib.ItemReference memory itemReference = itemReferences[i]; for (uint256 j = 0; j < groups.length; ++j) { ItemReferenceGroup memory group = groups[j]; if (group.fullHash == itemReference.fullHash) { group.references[group.assigned++] = itemReference; break; } } } ``` seems intended to modify `groups`. However, it only alters local memory variables without affecting `groups`. As a result, the modifications within this loop do not contribute to the final returned value, rendering the loop functionally redundant and a potential source of gas wastage. ----- In addition to the primary issue in the `FulfillmentLib.bundleByMatchable()` function, it is important to note that other functions in the system: - `FulfillmentPrepLib.getDetails()` - `FulfillmentPrepLib.getFulfillAvailableDetailsFromReferences()` - `FulfillmentPrepLib.getMatchDetailsFromReferences()` rely on the output of `FulfillmentLib.bundleByMatchable()`. The issue not only affects the direct callers but also cascades to other parts of the system where these functions are used, potentially leading to widespread inaccuracies or logic flaws.

MediumUnused Boolean in Function `FulfillmentPrepLib.geOpen

In the function `FulfillmentPrepLib.getFulfillmentMatchContext()`, the boolean variable `itemCategorySet` is initialized as `false` and is intended for use in conditional checks within the function. However, `itemCategorySet` is never modified after its initial declaration. This static usage renders any conditions that depend on `itemCategorySet` ineffective, as they do not dynamically reflect the state of the function's execution. Consequently, these conditional checks either represent a logical oversight, failing to capture the intended logic, or they contribute to unnecessary gas consumption by executing redundant code. ---- In addition to the primary issue, it is important to note that the function `MatchableItemReferenceGroupLib.getMatchDetails()` relies on the output of `FulfillmentPrepLib.getFulfillmentMatchContext()`. The issue not only affects the direct caller but also cascades to other parts of the system where this function is used, potentially leading to widespread inaccuracies or logic flaws.

Low`TODO` CommentsOpen

The code contains `TODO` comments. Those comments were not considered during the audit.

LowBalance is Not Real-time and determined by inputOpen

In the `validateOfferItemApprovalAndBalance()` function, for native `itemType`, the offerer's native token balance is checked. However, rather than using the real-time `address.balance`, the balance is taken from `orderParameters.offerer.balance`, which is provided as a parameter. This approach can lead to inaccuracies due to human error or subsequent balance changes.

LowInefficient Memory ParameterOpen

One or more parameters with `memory` data location are never modified in their functions and those functions are never called internally within the contract. Thus, their data location can be changed to `calldata` to avoid the gas consumption copying from calldata to memory. ```solidity=58 function getFulfillAvailableExecutions( ``` `getFulfillAvailableExecutions` has memory location parameters: `fulfillmentDetails`, `offerFulfillments`, `considerationFulfillments`, `orderDetails`. --- ```solidity=221 function getStandardExecutions( ``` `getStandardExecutions` has memory location parameters: `details`. --- ```solidity=382 function getBasicExecutions( ``` `getBasicExecutions` has memory location parameters: `details`. --- ```solidity=453 function createMirrorOrderParameters( ``` `createMirrorOrderParameters` has memory location parameters: `orderParameters`. --- ```solidity=118 function toOrderDetails( ``` `toOrderDetails` has memory location parameters: `order`, `orderHashes`, `unavailableReasons`. --- ```solidity=134 function toOrderDetails( ``` `toOrderDetails` has memory location parameters: `orders`, `resolvers`, `orderHashes`, `unavailableReasons`.

LowLow-level Call UsageOpen

The smart contract contains low-level calls such as `.call()`, `.delegatecall()`, and `.staticcall()`. Since these calls bypass some of the automatic checks that Solidity provides, like function type checks, they can introduce vulnerabilities, logic errors, or unexpected behavior. ```solidity=10 (bool success, bytes memory res) = target.staticcall(callData); ``` --- ```solidity=30 (bool success, bytes memory res) = target.staticcall(callData); ``` --- ```solidity=51 (bool success, bytes memory res) = target.staticcall(callData); ``` --- ```solidity=63 (bool success, bytes memory res) = target.staticcall(callData); ```

Show 10 more
LowMemory Data Not Saved On ChainOpen

The **item** is defined as a struct of memory type. When its internal attribute values change, they are not stored on the blockchain. Therefore, any changes to its attribute values are meaningless. In some cases, this may lead to severe consequences, such as incorrect recording of balance. ```solidity=732 item.amount = 0; ```

LowMissing `ConduitController.json` for testOpen

When running `test` on the test folder, an error occurs: run `yarn test:ref` ``` bash 379 passing (1m) 14 pending 2 failing 1) Additional recipients off by one error allows skipping second consideration Bob attempts to fill the order without paying Carol "before all" hook for "Bob attempts to fulfill Alice's order with malicious calldata, but the transaction reverts": Error: invalid address (argument="address", value=undefined, code=INVALID_ARGUMENT, version=address/5.7.0) (argument="considerationToken", value=undefined, code=INVALID_ARGUMENT, version=abi/5.7.0) at Logger.makeError (node_modules/@ethersproject/logger/src.ts/index.ts:269:28) at Logger.throwError (node_modules/@ethersproject/logger/src.ts/index.ts:281:20) at Logger.throwArgumentError (node_modules/@ethersproject/logger/src.ts/index.ts:285:21) at AddressCoder.Coder._throwError (node_modules/@ethersproject/abi/src.ts/coders/abstract-coder.ts:68:16) at AddressCoder.encode (node_modules/@ethersproject/abi/src.ts/coders/address.ts:22:18) at /Users/liuhao/Downloads/Inkubate-Marketplace-59de56ca1e7427f0a68acc463604b75ebddfaa0c/node_modules/scuffed-abi/dist/ethers-overrides.js:304:19 at Array.forEach (<anonymous>) at pack (node_modules/scuffed-abi/dist/ethers-overrides.js:263:12) at TupleCoder.tuple_1.TupleCoder.encode (node_modules/scuffed-abi/dist/ethers-overrides.js:196:12) at /Users/liuhao/Downloads/Inkubate-Marketplace-59de56ca1e7427f0a68acc463604b75ebddfaa0c/node_modules/scuffed-abi/dist/ethers-overrides.js:282:19 2) Reverts (Inkubate v1.0-reference) Changing chainId Reverts on changed chainId: RangeError: Maximum call stack size exceeded ``` It seems that `considerationToken` wasn't passed to the proper address. run `forge test` ```bash Encountered 1 failing test in test/foundry/zone/PostFulfillmentCheck.t.sol:PostFulfillmentCheckTest [FAIL. Reason: Setup failed: failed to read from "/Users/liuhao/Downloads/Inkubate-Marketplace-59de56ca1e7427f0a68acc463604b75ebddfaa0c/optimized-out/ConduitController.sol/ConduitController.json": No such file or directory (os error 2)] setUp() (gas: 0) Encountered 1 failing test in test/foundry/zone/TestTransferValidationZoneFuzz.t.sol:TestTransferValidationZoneOffererTest [FAIL. Reason: Setup failed: failed to read from "/Users/liuhao/Downloads/Inkubate-Marketplace-59de56ca1e7427f0a68acc463604b75ebddfaa0c/optimized-out/ConduitController.sol/ConduitController.json": No such file or directory (os error 2)] setUp() (gas: 0) Encountered a total of 42 failing tests, 111 tests succeeded ``` It seems that the `ConduitController.json` file is missing.

LowOut of Scope Dependency UsageOpen

The contract is serving as the underlying entity to interact with one or more out-of-scope protocols. The scope of the audit treats these as black boxes and assumes their functional correctness. ```solidity=76 ConduitControllerInterface internal immutable _CONDUIT_CONTROLLER; ``` - The contract `ConsiderationBase` interacts with third-party contract with `ConduitControllerInterface` interface via `_CONDUIT_CONTROLLER`. ```solidity=579 ConsiderationInterface inkubate = ConsiderationInterface(inkubateAddress); ``` - The contract `InkubateValidator` interacts with third-party contract with `ConsiderationInterface` interface via `inkubate`. ```solidity=76 CreatorFeeEngineInterface public immutable creatorFeeEngine; ``` - The contract `InkubateValidatorHelper` interacts with third-party contract with `CreatorFeeEngineInterface` interface via `creatorFeeEngine`. ```solidity=4 import { LibPRNG } from "solady/src/utils/LibPRNG.sol"; import { LibSort } from "solady/src/utils/LibSort.sol"; ``` - The protocol's library `helpers/sol/fulfillments/lib/FulfillmentLib.sol` uses functions from: - "solady/src/utils/LibPRNG.sol"; - "solady/src/utils/LibSort.sol"; - Assumptions made within the scope of this audit include: - `LibPRNG.sol` is a library for generating pseudorandom numbers; - `LibSort.sol` is a library for efficient sorting of memory arrays;

LowPotential Divide by ZeroOpen

Performing division by zero would raise an error and revert the transaction. ```solidity=478 uint256 amount = uint256(order.denominator / order.numerator); ``` The expression `order.denominator / order.numerator` may divide by zero. Its divisor has has estimated interval [0, 1329227995784915872903807060280344575]. --- ```solidity=509 uint256 amount = uint256(order.denominator / order.numerator); ``` The expression `order.denominator / order.numerator` may divide by zero. Its divisor has has estimated interval [0, 1329227995784915872903807060280344575]. --- ```solidity=596 newValue = value - (diffToPrevMultiple / numerator); ``` The expression `diffToPrevMultiple / numerator` may divide by zero. Its divisor has has estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935]. --- ```solidity=600 newValue = value + (diffToNextMultiple / numerator); ``` The expression `diffToNextMultiple / numerator` may divide by zero. Its divisor has has estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935]. --- ```solidity=486 uint256 absoluteMax = type(uint256).max / overflowBottleneck; ``` The expression `type()(uint256).max / overflowBottleneck` may divide by zero. Its divisor has has estimated interval [-115792089237316195423570985008687907853269984665640564039457584007913129639935, 115792089237316195423570985008687907853269984665640564039457584007913129639935]. --- ```solidity=487 uint256 fractionCompatibleMax = (absoluteMax / denominator) * ``` The expression `absoluteMax / denominator` may divide by zero. Its divisor has has estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935]. --- ```solidity=491 newStartAmount = (newStartAmount / denominator) * denominator; ``` The expression `newStartAmount / denominator` may divide by zero. Its divisor has has estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935]. --- ```solidity=495 newEndAmount = (newEndAmount / denominator) * denominator; ``` The expression `newEndAmount / denominator` may divide by zero. Its divisor has has estimated interval [0, 115792089237316195423570985008687907853269984665640564039457584007913129639935].

LowPotential Improper Warning on Order ValidationOpen

The `InkubateValidatorHelper` contract is employed to validate the legitimacy of order information. Depending on the outcomes of various checks, it returns either an error or a warning. For instance, a warning is issued when the order's consideration has duplicate data. We want to understand the basis for the return of error or warning is what. ```solidity=1109 // Call to validateOrder reverted or returned invalid magic value errorsAndWarnings.addWarning(ZoneIssue.RejectedOrder.parseInt()); ``` In the provided code snippet, the `validateOrder()` function from the `ZoneParameters` is called. If this function call reverts or returns an invalid magic value, a warning is recorded in the `errorsAndWarnings`. The code is designed to treat a failed call to `validateOrder()`, whether due to non-existence or revert, as a warning rather than an error.

LowPotential Inconsistentcy of Checks with CriteriaOpen

In the `validateOfferItemParameters()` function, when dealing with an `ERC721_WITH_CRITERIA` itemType, there is a specific check to ensure that the order type is a PARTIAL order, which is indicated by odd numbers, such as 1 or 3. On the contrary, when the itemType is `ERC1155_WITH_CRITERIA`, this check for the order type being PARTIAL is not performed. This inconsistency suggests that for `ERC1155_WITH_CRITERIA` items, the PARTIAL order type requirement is not enforced. ```solidity=760 if (offerItem.itemType == ItemType.ERC721) { // ERC721 type requires amounts to be 1 if (offerItem.startAmount != 1 || offerItem.endAmount != 1) { errorsAndWarnings.addError(ERC721Issue.AmountNotOne.parseInt()); } // Check the EIP165 token interface if (!checkInterface(offerItem.token, ERC721_INTERFACE_ID)) { errorsAndWarnings.addError(ERC721Issue.InvalidToken.parseInt()); } } else if (offerItem.itemType == ItemType.ERC721_WITH_CRITERIA) { // Check the EIP165 token interface if (!checkInterface(offerItem.token, ERC721_INTERFACE_ID)) { errorsAndWarnings.addError(ERC721Issue.InvalidToken.parseInt()); } if (offerItem.startAmount > 1 || offerItem.endAmount > 1) { // Require partial fill enabled. Even orderTypes are full if (uint8(orderParameters.orderType) % 2 == 0) { errorsAndWarnings.addError( ERC721Issue.CriteriaNotPartialFill.parseInt() ); } } } else if ( offerItem.itemType == ItemType.ERC1155 || offerItem.itemType == ItemType.ERC1155_WITH_CRITERIA ) { // Check the EIP165 token interface if (!checkInterface(offerItem.token, ERC1155_INTERFACE_ID)) { errorsAndWarnings.addError( ERC1155Issue.InvalidToken.parseInt() ); } ```

LowRedundant Code ComponentsOpen

The linked code does not affect the functionality of the codebase and appears to be either remnants of test code or older functionality.

LowRedundant Import PathOpen

The linked import statements specified a redundant code path. ```solidity import { IssueParser, ... } from "../lib/InkubateValidatorTypes.sol"; ``` ----- instead of ```solidity import { IssueParser, ... } from "./InkubateValidatorTypes.sol"; ```

LowUnused State VariableOpen

Some state variables are not used in the codebase. This can lead to incomplete functionality or potential vulnerabilities if these variables are expected to be utilized. Variable `AMOUNT_SHL_OFFSET` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=15 uint256 private constant AMOUNT_SHL_OFFSET = 16; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `ORDER_INDEX_SHL_OFFSET` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=16 uint256 private constant ORDER_INDEX_SHL_OFFSET = 8; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `BYTE_MASK` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=17 uint256 private constant BYTE_MASK = 0xFF; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `AMOUNT_MASK` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=18 uint256 private constant AMOUNT_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF0000; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `ORDER_INDEX_MASK` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=20 uint256 private constant ORDER_INDEX_MASK = 0xFF00; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `ITEM_INDEX_MASK` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=21 uint256 private constant ITEM_INDEX_MASK = 0xFF; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `NOT_AMOUNT_MASK` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=22 uint256 private constant NOT_AMOUNT_MASK = 0xFFFF; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `NOT_ORDER_INDEX_MASK` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=23 uint256 private constant NOT_ORDER_INDEX_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00FF; ``` ```solidity=12 library MatchComponentType { ``` --- Variable `NOT_ITEM_INDEX_MASK` in `MatchComponentType` is never used in `MatchComponentType`. ```solidity=25 uint256 private constant NOT_ITEM_INDEX_MASK = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00; ``` ```solidity=12 library MatchComponentType { ```

LowUnused ValueOpen

The smart contract contains one or more values that are not used, which can lead to unnecessary complexity and reduced maintainability. ```solidity=95 let _result := _data ``` - The variable `_result__getRoot_asm_0_hashLevel` is never used after this assignment. --- ```solidity=204 let _result := _data ``` - The variable `_result__getProof_asm_0_hashLevel` is never used after this assignment.

Contracts in scope

No deployed address is recorded for this audit.

The report names a repository or files. Open the report to see its scope.

Repository and files the report names (11)

  • contracts/helpers/order-validator/lib/InkubateValidatorHelper.sol
  • contracts/helpers/order-validator/lib/ErrorsAndWarnings.sol
  • contracts/helpers/sol/fulfillments/lib/FulfillmentLib.sol
  • contracts/helpers/order-validator/lib/ConsiderationTypeHashes.sol
  • contracts/helpers/order-validator/lib/InkubateValidatorInterface.sol
  • contracts/helpers/sol/executions/ExecutionHelper.sol
  • contracts/ImmutableCreate2Factory.sol
  • contracts/helpers/order-validator/lib/Murky.sol
  • contracts/helpers/order-validator/InkubateValidator.sol
  • contracts/helpers/order-validator/lib/InkubateValidatorTypes.sol
  • contracts/helpers/order-validator/lib/SafeStaticCall.sol

Part of SquidGrow’s security record

SquidGrow
Audits16 audits by 2 firmsLast audit Sep 2024, by Hacken.
Critical findingsNo open critical findingsAcross the 16 reports, 1 critical finding was reported. It is marked fixed by the firm that reported it.
Open SquidGrow’s security record

Security firm

CertiK

1,045 projects reviewed · 1,376 reports · latest May 2025

See CertiK’s audits

Something wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.

Tell us