Glif Filecoin InfinityPool

1 Executive Summary

This report presents the results of our engagement with the GLIF team to review a new Filecoin leasing protocol for Filecoin Storage Providers called GLIF Pools. The goal of the Protocol is to make possible the deployment of multiple Filecoin leasing pools, allowing a single Agent (representing a Filecoin Storage Provider) to lease FIL for use as pledge collateral on the Filecoin blockchain. This audit focused on the underlying Protocol code, as well as the Infinity Pool implementation as the first leasing pool built on the Protocol.

The review was conducted over three weeks, from April 10th, 2023 to April 28th, 2023, by Chingiz Mardanov and Sergii Kravchenko. A total of 5 person-weeks were spent. The fixes were reviewed over 3 days, from May 3d, 2023 to May 5th, 2023.

Prior to this review, a 10 person-weeks, informal protocol review occurred, after which the code was significantly changed. We are happy to mention that the code size, quality and business logic were drastically improved, making it easier to understand and audit the codebase. While this is the case, we still have identified several major issues that needed to be addressed. We also would like to mention that given the short time alloted for the audit and several trust assumptions the Protocol has to be used cautiously.

The GLIF Pools protocol has a large potential feature set and surface area, so the following assumptions were made about the state of the system in order to conduct an audit in a reasonable amount of time:

• The system contains only 1 leasing pool.
• The Agent Data Oracle is controlled solely by the GLIF team.
• All owner and operator keys with control over important parts of the Protocol are multisig wallets controlled by the GLIF team.
• The Filecoin precompiles used throughout the Protocol to interact with Filecoin’s built-in Minor Actor have already been audited.

Any changes to the protocol code, such as upgrades, adding off-ramp or adding additional pools, must undergo additional audits.

The security of this Protocol relies heavily on the centralization nature of its current state and any decrease in the centralization must be carefully evaluated and audited. Users must understand that the GLIF Pools Protocol is centralized and controlled by the GLIF team. We also talk about this in Trust Model section. All the issues were addressed by the GLIF team, the details of which can be found in the Findings section.

2 Scope

Our review focused on the commit hash bf28b412e0e13c87b1dfdcf4cb6ee2707bbe44f8. The list of files in scope can be found in the Appendix. The fixes were presented on the commit hash 070dae7820c9299eb610f3300b0ae5e35b139913.

2.1 Objectives

Together with the GLIF team, we identified the following priorities for our review:

1. Correctness of the implementation, consistent with the intended functionality and without unintended edge cases.
2. Identify known vulnerabilities particular to smart contract systems, as outlined in our Smart Contract Best Practices, and the Smart Contract Weakness Classification Registry.

3 Security Specification

This section describes, from a security perspective, the expected behavior of the system under audit. It is not a substitute for documentation. The purpose of this section is to identify specific security properties that were validated by the audit team.

3.1 Actors

In the current system we can identify a few key actors. In order to simplify things we will do that from two different levels: external and internal relative the protocol.

On external level we have 3 main actors:

• Depositors - users who are willing to provide capital depending on the terms of the specific pool. From their perspective they are interacting with an ERC4626 vault that will have withdrawals done via a queuing system.
• Filecoin Storage Providers - are the once that will borrow the capital provided by the depositors. Those funds can either be withdrawn, when correct computerization checks are passed or used to further expand the storage provision operation.
• GLIF Protocol - acts as a place where depositors and borrowers can be matched based on the deals they would like to support.
• Oracle - is used to get the miners information of the storage provider is initially controlled by the GLIF team. Values that are passed using this oracle are crucial to the correct operation of the protocol.

On the internal level things are a bit more complex. Now we will outline the main participants that build up the main protocol.

InfinityPool - is an actor where the main actions of the protocol would happen. This pools is where depositors can deposit their funds wFIL and FIL in the current iteration and Agents can later borrow those funds.

Agent - is the contract that represents the borrower in the context of the protocol. Agent will obtain control over all of the storage provider’s miners. Transferring the ownership over the miners to the Agent contract is what prevents the borrower from running away with the borrowed funds. Agent can be though of as borrowers bank account and only funds that are not used as collateral can be withdrawn from that account.

AgentPolice - is a contract that will be controlled by the GLIF team from launch. AgentPolice verifies actions that are taking place on chain as well as oversee processes such as putting an Agent in administration or liquidating and Agent in default.

3.2 Trust Model

After thoroughly reviewing the codebase we would like to highlight that it heavily relies on a strong trust assumption that the development team will not only act with integrity and good faith but also exercise a high level of caution when making any future code changes. While we understand that trust is a fundamental aspect of any collaborative project, it is important to acknowledge that this trust assumption presents a significant risk to the security and reliability of the system. Such trust assumption include but are not limited to:

• Upgradeability of the majority of the contract such as PoolRegistry, MinerRegistry, Agent e.t.c.
• Since upgradeability is done in a rather complex manner of redeploying contracts with previously non-empty state any upgrades should be done extremely carefully after an extensive testing and verification.
• For proper operation all actions that borrowers can take rely on the data submitted by a centralized oracle operated by the GLIF team. If that oracle starts reporting incorrect values the entire protocol security will be jeopardized.
• Entire concept of administration as well as the fact that AgentPolice controlled by the GLIF team, means that there are several ways in which the GLIF team could hijack the users funds. This applies to both borrowers and depositors.

4 System Overview

• PoolRegistry - A contract that keeps track of all the leasing pools. At launch there will be only one pool called InfinityPool. We operated under assumption that given code base will only work with one leasing pool.

• InfinityPool - Main contract where most of the borrowing and leasing logic is contained.

• PoolToken:Share - Contract that will represent the share of the depositor in a particular pool.

• PoolToken:iou - Token that represents the debt of the pool in front of the depositor. You can also think of this as a ticket in a withdraw queue.

• Agent - A contract that will control the storage providers miners or any funds that can not be withdrawn. All the actions that the storage providers would like to perform will be done via the Agent contract.

• Account - A new struct that is created every time a lessor’s Agent opens a borrow position in a new pool.

• AgentPolice - Contract controlled by the GLIF team that allows them to take control over agents and perform liquidations.

• Centralized Oracle - A server that reports the signed on chain data to the Agent. This information is required to make sure that Agent can not enter bad state such as over-collateralized state for example.

5 Findings

Each issue has an assigned severity:

• Minor issues are subjective in nature. They are typically suggestions around best practices or readability. Code maintainers should use their own judgment as to whether to address such issues.
• Medium issues are objective in nature but are not security vulnerabilities. These should be addressed unless there is a clear reason not to.
• Major issues are security vulnerabilities that may not be directly exploitable or may require certain conditions in order to be exploited. All major issues should be addressed.
• Critical issues are directly exploitable security vulnerabilities that need to be fixed.

function borrow(VerifiableCredential memory vc) external isOpen subjectIsAgentCaller(vc) {
    // 1e18 => 1 FIL, can't borrow less than 1 FIL
    if (vc.value < WAD) revert InvalidParams();
    // can't borrow more than the pool has
    if (totalBorrowableAssets() < vc.value) revert InsufficientLiquidity();
    Account memory account = _getAccount(vc.subject);
    // fresh account, set start epoch and epochsPaid to beginning of current window
    if (account.principal == 0) {
        uint256 currentEpoch = block.number;
        account.startEpoch = currentEpoch;
        account.epochsPaid = currentEpoch;
        GetRoute.agentPolice(router).addPoolToList(vc.subject, id);
    }

    account.principal += vc.value;
    account.save(router, vc.subject, id);

    totalBorrowed += vc.value;

    emit Borrow(vc.subject, vc.value);

    // interact - here `msg.sender` must be the Agent bc of the `subjectIsAgentCaller` modifier
    asset.transfer(msg.sender, vc.value);
}

modifier subjectIsAgentCaller(VerifiableCredential memory vc) {
    if (
        GetRoute.agentFactory(router).agents(msg.sender) != vc.subject
    ) revert Unauthorized();
    _;
}

// transfer the assets into the pool
// whatever we couldn't pay back
uint256 lostAmt = principalOwed > recoveredFunds ? principalOwed - recoveredFunds : 0;

uint256 totalOwed = interestPaid + principalOwed;

asset.transferFrom(
  msg.sender,
  address(this),
  totalOwed > recoveredFunds ? recoveredFunds : totalOwed
);
// write off only what we lost
totalBorrowed -= lostAmt;
// set the account with the funds the pool lost
account.principal = lostAmt;

account.save(router, agentID, id);

// pay interest and principal
principalPaid = vc.value - interestOwed;
// the fee basis only applies to the interest payment
feeBasis = interestOwed;
// protect against underflow
totalBorrowed -= (principalPaid > totalBorrowed) ? 0 : principalPaid;
// fully paid off
if (principalPaid >= account.principal) {
    // remove the account from the pool's list of accounts
    GetRoute.agentPolice(router).removePoolFromList(vc.subject, id);
    // return the amount of funds overpaid
    refund = principalPaid - account.principal;
    // reset the account
    account.reset();
} else {
    // interest and partial principal payment
    account.principal -= principalPaid;
    // move the `epochsPaid` cursor to mark the account as "current"
    account.epochsPaid = block.number;
}

totalBorrowed -= (principalPaid > totalBorrowed) ? 0 : principalPaid;

function beneficiaryWithdrawable(
  address recipient,
  address sender,
  uint256 agentID,
  uint256 proposedAmount
) external returns (
  uint256 amount
) {
  AgentBeneficiary memory beneficiary = _agentBeneficiaries[agentID];
  address benneficiaryAddress = beneficiary.active.beneficiary;
  // If the sender is not the owner of the Agent or the beneficiary, revert
  if(
    !(benneficiaryAddress == sender || (IAuth(msg.sender).owner() == sender && recipient == benneficiaryAddress) )) {
      revert Unauthorized();
    }
  (
    beneficiary,
    amount
  ) = beneficiary.withdraw(proposedAmount);
  // update the beneficiary in storage
  _agentBeneficiaries[agentID] = beneficiary;
}

  sendAmount = agentPolice.beneficiaryWithdrawable(receiver, msg.sender, id, sendAmount);
}
else if (msg.sender != owner()) {
  revert Unauthorized();
}

// unwrap any wfil needed to withdraw
_poolFundsInFIL(sendAmount);
// transfer funds
payable(receiver).sendValue(sendAmount);

function borrow(VerifiableCredential memory vc) external isOpen subjectIsAgentCaller(vc) {
    // 1e18 => 1 FIL, can't borrow less than 1 FIL
    if (vc.value < WAD) revert InvalidParams();
    // can't borrow more than the pool has
    if (totalBorrowableAssets() < vc.value) revert InsufficientLiquidity();
    Account memory account = _getAccount(vc.subject);
    // fresh account, set start epoch and epochsPaid to beginning of current window
    if (account.principal == 0) {
        uint256 currentEpoch = block.number;
        account.startEpoch = currentEpoch;
        account.epochsPaid = currentEpoch;
        GetRoute.agentPolice(router).addPoolToList(vc.subject, id);
    }

    account.principal += vc.value;
    account.save(router, vc.subject, id);

    totalBorrowed += vc.value;

    emit Borrow(vc.subject, vc.value);

    // interact - here `msg.sender` must be the Agent bc of the `subjectIsAgentCaller` modifier
    asset.transfer(msg.sender, vc.value);
}

function distributeLiquidatedFunds(uint256 agentID, uint256 amount) external {
  if (!liquidated[agentID]) revert Unauthorized();

  // transfer the assets into the pool
  GetRoute.wFIL(router).transferFrom(msg.sender, address(this), amount);
  _writeOffPools(agentID, amount);
}

uint256 totalOwed = interestPaid + principalOwed;

asset.transferFrom(
  msg.sender,
  address(this),
  totalOwed > recoveredFunds ? recoveredFunds : totalOwed
);
// write off only what we lost
totalBorrowed -= lostAmt;
// set the account with the funds the pool lost
account.principal = lostAmt;

account.save(router, agentID, id);

emit WriteOff(agentID, recoveredFunds, lostAmt, interestPaid);

function upgradeAgent(
  address agent
) external returns (address newAgent) {
  IAgent oldAgent = IAgent(agent);
  address owner = IAuth(address(oldAgent)).owner();
  uint256 agentId = agents[agent];
  // only the Agent's owner can upgrade, and only a registered agent can be upgraded
  if (owner != msg.sender || agentId == 0) revert Unauthorized();
  // deploy a new instance of Agent with the same ID and auth
  newAgent = GetRoute.agentDeployer(router).deploy(
    router,
    agentId,
    owner,
    IAuth(address(oldAgent)).operator()
  );
  // Register the new agent and unregister the old agent
  agents[newAgent] = agentId;
  // transfer funds from old agent to new agent and mark old agent as decommissioning
  oldAgent.decommissionAgent(newAgent);
  // delete the old agent from the registry
  agents[agent] = 0;
}

function upgradeAgent(
  address agent
) external returns (address newAgent) {
  IAgent oldAgent = IAgent(agent);
  address owner = IAuth(address(oldAgent)).owner();
  uint256 agentId = agents[agent];
  // only the Agent's owner can upgrade, and only a registered agent can be upgraded
  if (owner != msg.sender || agentId == 0) revert Unauthorized();
  // deploy a new instance of Agent with the same ID and auth
  newAgent = GetRoute.agentDeployer(router).deploy(
    router,
    agentId,
    owner,
    IAuth(address(oldAgent)).operator()
  );
  // Register the new agent and unregister the old agent
  agents[newAgent] = agentId;
  // transfer funds from old agent to new agent and mark old agent as decommissioning
  oldAgent.decommissionAgent(newAgent);
  // delete the old agent from the registry
  agents[agent] = 0;
}

function decommissionAgent(address _newAgent) external {
  // only the agent factory can decommission an agent
  AuthController.onlyAgentFactory(router, msg.sender);
  // if the newAgent has a mismatching ID, revert
  if(IAgent(_newAgent).id() != id) revert Unauthorized();
  // set the newAgent in storage, which marks the upgrade process as starting
  newAgent = _newAgent;
  uint256 _liquidAssets = liquidAssets();
  // Withdraw all liquid funds from the Agent to the newAgent
  _poolFundsInFIL(_liquidAssets);
  // transfer funds to new agent
  payable(_newAgent).sendValue(_liquidAssets);
}

/*//////////////////////////////////////////////////////////////
                        4626 LOGIC
//////////////////////////////////////////////////////////////*/

/**
 * @dev Converts `assets` to shares
 * @param assets The amount of assets to convert
 * @return shares - The amount of shares converted from assets
 */
function convertToShares(uint256 assets) public view returns (uint256) {
    uint256 supply = liquidStakingToken.totalSupply(); // Saves an extra SLOAD if totalSupply is non-zero.

    return supply == 0 ? assets : assets * supply / totalAssets();
}

/**
 * @dev Converts `shares` to assets
 * @param shares The amount of shares to convert
 * @return assets - The amount of assets converted from shares
 */
function convertToAssets(uint256 shares) public view returns (uint256) {
    uint256 supply = liquidStakingToken.totalSupply(); // Saves an extra SLOAD if totalSupply is non-zero.

    return supply == 0 ? shares : shares * totalAssets() / supply;
}

function maxWithdraw(address owner) public view returns (uint256) {
    return convertToAssets(liquidStakingToken.balanceOf(owner));
}

mapping(uint256 => bool) public liquidated;

/// @notice `_poolIDs` maps agentID to the pools they have actively borrowed from
mapping(uint256 => uint256[]) private _poolIDs;

/// @notice `_credentialUseBlock` maps signature bytes to when a credential was used
mapping(bytes32 => uint256) private _credentialUseBlock;

/// @notice `_agentBeneficiaries` maps an Agent ID to its Beneficiary struct
mapping(uint256 => AgentBeneficiary) private _agentBeneficiaries;

mapping(bytes32 => bool) private _minerRegistered;

mapping(uint256 => uint64[]) private _minersByAgent;

function mint(uint256 shares, address receiver) public isOpen returns (uint256 assets) {
    if(shares == 0) revert InvalidParams();
    // These transfers need to happen before the mint, and this is forcing a higher degree of coupling than is ideal
    assets = previewMint(shares);
    asset.transferFrom(msg.sender, address(this), assets);
    liquidStakingToken.mint(receiver, shares);
    assets = convertToAssets(shares);
    emit Deposit(msg.sender, receiver, assets, shares);
}

return balance -= feesCollected;

if (vc.value <= interestOwed) {
    // compute the amount of epochs this payment covers
    // vc.value is not WAD yet, so divWadDown cancels the extra WAD in interestPerEpoch
    uint256 epochsForward = vc.value.divWadDown(interestPerEpoch);
    // update the account's `epochsPaid` cursor
    account.epochsPaid += epochsForward;
    // since the entire payment is interest, the entire payment is used to compute the fee (principal payments are fee-free)
    feeBasis = vc.value;
} else {

uint256 epochsForward = vc.value.divWadDown(interestPerEpoch);

function jumpStartAccount(address receiver, uint256 agentID, uint256 accountPrincipal) external onlyOwner {
    Account memory account = _getAccount(agentID);
    // if the account is already initialized, revert
    if (account.principal != 0) revert InvalidState();
    // create the account
    account.principal = accountPrincipal;
    account.startEpoch = block.number;
    account.epochsPaid = block.number;
    // save the account
    account.save(router, agentID, id);
    // add the pool to the agent's list of borrowed pools
    GetRoute.agentPolice(router).addPoolToList(agentID, id);
    // mint the iFIL to the receiver, using principal as the deposit amount
    liquidStakingToken.mint(receiver, convertToShares(accountPrincipal));
    // account for the new principal in the total borrowed of the pool
    totalBorrowed += accountPrincipal;
}

function migrateMiner(uint64 miner) external {
  if (newAgent != msg.sender) revert Unauthorized();
  uint256 newId = IAgent(newAgent).id();
  if (
    // first check to make sure the agentFactory knows about this "agent"
    GetRoute.agentFactory(router).agents(newAgent) != newId ||
    // then make sure this is the same agent, just upgraded
    newId != id ||
    // check to ensure this miner was registered to the original agent
    !minerRegistry.minerRegistered(id, miner)
  ) revert Unauthorized();

  // propose an ownership change (must be accepted in v2 agent)
  miner.changeOwnerAddress(newAgent);

  emit MigrateMiner(msg.sender, newAgent, miner);
}

Appendix 1 - Files in Scope

This audit covered the following files:

Appendix 2 - Disclosure

ConsenSys Diligence (“CD”) typically receives compensation from one or more clients (the “Clients”) for performing the analysis contained in these reports (the “Reports”). The Reports may be distributed through other means, including via ConsenSys publications and other distributions.

The Reports are not an endorsement or indictment of any particular project or team, and the Reports do not guarantee the security of any particular project. This Report does not consider, and should not be interpreted as considering or having any bearing on, the potential economics of a token, token sale or any other product, service or other asset. Cryptographic tokens are emergent technologies and carry with them high levels of technical risk and uncertainty. No Report provides any warranty or representation to any Third-Party in any respect, including regarding the bugfree nature of code, the business model or proprietors of any such business model, and the legal compliance of any such business. No third party should rely on the Reports in any way, including for the purpose of making any decisions to buy or sell any token, product, service or other asset. Specifically, for the avoidance of doubt, this Report does not constitute investment advice, is not intended to be relied upon as investment advice, is not an endorsement of this project or team, and it is not a guarantee as to the absolute security of the project. CD owes no duty to any Third-Party by virtue of publishing these Reports.

PURPOSE OF REPORTS The Reports and the analysis described therein are created solely for Clients and published with their consent. The scope of our review is limited to a review of code and only the code we note as being within the scope of our review within this report. Any Solidity code itself presents unique and unquantifiable risks as the Solidity language itself remains under development and is subject to unknown risks and flaws. The review does not extend to the compiler layer, or any other areas beyond specified code that could present security risks. Cryptographic tokens are emergent technologies and carry with them high levels of technical risk and uncertainty. In some instances, we may perform penetration testing or infrastructure assessments depending on the scope of the particular engagement.

CD makes the Reports available to parties other than the Clients (i.e., “third parties”) – on its website. CD hopes that by making these analyses publicly available, it can help the blockchain ecosystem develop technical best practices in this rapidly evolving area of innovation.

LINKS TO OTHER WEB SITES FROM THIS WEB SITE You may, through hypertext or other computer links, gain access to web sites operated by persons other than ConsenSys and CD. Such hyperlinks are provided for your reference and convenience only, and are the exclusive responsibility of such web sites’ owners. You agree that ConsenSys and CD are not responsible for the content or operation of such Web sites, and that ConsenSys and CD shall have no liability to you or any other person or entity for the use of third party Web sites. Except as described below, a hyperlink from this web Site to another web site does not imply or mean that ConsenSys and CD endorses the content on that Web site or the operator or operations of that site. You are solely responsible for determining the extent to which you may use any content at any other web sites to which you link from the Reports. ConsenSys and CD assumes no responsibility for the use of third party software on the Web Site and shall have no liability whatsoever to any person or entity for the accuracy or completeness of any outcome generated by such software.

TIMELINESS OF CONTENT The content contained in the Reports is current as of the date appearing on the Report and is subject to change without notice. Unless indicated otherwise, by ConsenSys and CD.