Boost.sol

Overview

Boost.sol defines the Boost smart contract, which is an auxiliary contract designed to work closely with the PopitGame contract. It provides mechanisms for managing and updating an internal state variable (_mbiCur), interacting with the PopitGame contract, and enabling controlled upgrade and destruction of the contract itself. The contract includes strict access control through ownership verification and sender restrictions.

This contract imports several dependencies, including custom modifiers (Modifiers), a verifier library (VerifiersLib), the root contract (MobileVerifiersContractRoot), and the PopitGame contract, allowing it to integrate securely and efficiently with the broader system.

Contract: Boost

State Variables

Variable	Type	Description
`version`	`string`	Constant string representing the contract version (`"1.0.0"`).
`_wallet`	`address`	Address of the wallet associated with this contract.
`_popitGame`	`address`	Static address of the linked `PopitGame` contract. This is set at deployment and immutable.
`_root`	`address`	Address of the root contract derived from the contract's code salt.
`_mbiCur`	`uint64`	Current value of the mobile boost index or similar metric managed by this contract.
`_rootPubkey`	`uint256`	Public key of the root owner, used for access control.

Constructor

constructor (address wallet, uint256 rootPubkey) senderIs(_popitGame) accept

Purpose: Initializes the contract with the wallet address and root owner public key. It verifies the sender and ensures the contract's code salt matches the expected library version.
Parameters:
- wallet: The wallet address to be associated with this contract.
- rootPubkey: Public key of the root owner for ownership verification.
Behavior:
- Decodes the contract's code salt to extract the library version and root address.
- Verifies that the version of the verifier library matches the expected version.
- Sets _root, _wallet, and _rootPubkey accordingly.
Modifiers Used:
- senderIs(_popitGame): Ensures only the PopitGame contract can deploy this contract.
- accept: Accepts the incoming external message.

Private Functions

ensureBalance()

function ensureBalance() private pure

Purpose: Ensures the contract maintains a minimum balance defined by CONTRACT_BALANCE (presumably a constant in the modifiers or imported files).
Behavior:
- Checks if the contract's balance exceeds CONTRACT_BALANCE.
- If not, mints tokens (via gosh.mintshellq(CONTRACT_BALANCE)) to top up the balance.
Note: This method is marked as pure but performs an external call to mint tokens, indicating possible inconsistency or reliance on compiler specifics.

Public Functions

deleteMbiCur()

function deleteMbiCur() public senderIs(_popitGame) accept

Purpose: Resets the _mbiCur variable to zero.
Access Control: Can only be called by the PopitGame contract.
Behavior:
- Calls ensureBalance() to maintain contract balance before state change.
- Sets _mbiCur to 0.

setMbiCur(uint64 mbiCur)

function setMbiCur(uint64 mbiCur) public onlyOwnerPubkey(_rootPubkey) accept

Purpose: Updates the _mbiCur value and notifies the linked PopitGame contract about this update.
Parameters:
- mbiCur: New value to set for _mbiCur.
Access Control: Only callable by the owner identified by _rootPubkey.
Behavior:
- Calls ensureBalance() to maintain balance.
- Sets _mbiCur to the provided value.
- Calls PopitGame(_popitGame).setMbiCur with a small value transfer (0.1 vmshell) and a flag to change state.

updateCode(TvmCell newcode, TvmCell cell)

function updateCode(TvmCell newcode, TvmCell cell) public view onlyOwnerPubkey(_rootPubkey) accept

Purpose: Allows the contract owner to update the contract's code, enabling contract upgradeability.
Parameters:
- newcode: New contract code to set.
- cell: Additional data passed to onCodeUpgrade.
Access Control: Only callable by the owner identified by _rootPubkey.
Behavior:
- Calls ensureBalance().
- Sets the contract's code and current code to newcode.
- Calls onCodeUpgrade(cell) for any post-upgrade initialization (empty implementation here).

onCodeUpgrade(TvmCell cell)

function onCodeUpgrade(TvmCell cell) private pure

Purpose: Hook for code upgrade logic.
Parameters:
- cell: Data for post-upgrade initialization.
Behavior: Empty implementation, reserved for override or future use.

destroyNode()

function destroyNode() public senderIs(address(this)) accept

Purpose: Self-destructs the contract.
Access Control: Only callable by the contract itself.
Behavior:
- Calls selfdestruct sending remaining balance to the contract’s own address.

getDetails()

function getDetails() external view returns(uint64 mbiCur, address wallet)

Purpose: Returns current state details of the contract.
Returns:
- _mbiCur: Current mobile boost index value.
- _wallet: Wallet address associated with the contract.

getVersion()

function getVersion() external pure returns(string, string)

Purpose: Returns the contract version and name.
Returns:
- version: Contract version string ("1.0.0").
- "Boost": Contract name.

Implementation Details and Algorithms

The contract uses a code salt mechanism to validate deployment origin and compatibility with the verifier library version.
Access control is enforced using senderIs and onlyOwnerPubkey modifiers, which are imported from Modifiers.sol. These ensure that only authorized entities (e.g., the PopitGame contract or the root owner) can invoke sensitive functions.
The ensureBalance function attempts to prevent contract failure due to insufficient funds by minting tokens when balance is below a certain threshold.
The setMbiCur function not only updates the internal state but also notifies the PopitGame contract with a small value transfer and a specific flag, indicating a state change that may trigger further processing in the game contract.
Upgradeability is supported via updateCode which replaces the contract code and invokes an upgrade hook, a common pattern in smart contract design to enable fixes and feature additions.
The contract supports self-destruction with controlled invocation limited to itself, preventing unauthorized destruction.

Interactions with Other Contracts

PopitGame Contract:
- The _popitGame address is static and represents the linked game contract.
- deleteMbiCur and setMbiCur functions can only be called or initiated by authorized entities and communicate state updates back to the PopitGame contract.
- The contract sends a small value transfer to PopitGame during setMbiCur to notify about the update.
VerifiersLib:
- Used to validate the version of the verifier library embedded in the contract's code salt during construction.
Modifiers:
- Provides access control and sender verification logic.
MobileVerifiersContractRoot:
- The _root address is derived from code salt and represents the root contract, indicating a hierarchical contract structure.

Visual Diagram

classDiagram
class Boost {
-string version
-address _wallet
-address static _popitGame
-address _root
-uint64 _mbiCur
-uint256 _rootPubkey
+constructor(wallet, rootPubkey)
-ensureBalance()
+deleteMbiCur()
+setMbiCur()
+updateCode()
-onCodeUpgrade()
+destroyNode()
+getDetails()
+getVersion()
}
Boost ..> Modifiers : inherits
Boost --> PopitGame : interacts with
Boost --> VerifiersLib : verifies version

This diagram illustrates the Boost contract's main state variables and methods, its inheritance from Modifiers, and its interaction dependencies with the PopitGame contract and VerifiersLib library.