Git Source

Inherits: INexus, EIP712, BaseAccount, ExecutionHelper, ModuleManager, UUPSUpgradeable

This contract integrates various functionalities to handle modular smart accounts compliant with ERC-7579 and ERC-4337 standards.

Comprehensive suite of methods for managing smart accounts, integrating module management, execution management, and upgradability via UUPS.

• Nexus
  • Table of Contents
  • State Variables
    • _MESSAGE_TYPEHASH
    • _SELF
    • _PERSONAL_SIGN_TYPEHASH
  • Functions
    • constructor
    • validateUserOp
    • execute
    • executeFromExecutor
    • executeUserOp
    • installModule
    • uninstallModule
    • initializeAccount
    • isValidSignature
    • getImplementation
    • supportsModule
    • supportsExecutionMode
    • isModuleInstalled
    • hashTypedData
    • DOMAIN_SEPARATOR
    • accountId
    • upgradeToAndCall
    • replaySafeHash
    • _authorizeUpgrade
    • _eip712Hash
    • _erc1271HashForIsValidSignatureViaNestedEIP712
    • _domainNameAndVersion
    • _handleSingleExecution
    • _handleBatchExecution
    • _isModuleInstalled
    • _typedDataSignFields

*Precomputed typeHash used to produce EIP-712 compliant hash when applying the anti cross-account-replay layer. The original hash must either be:

• An EIP-191 hash: keccak256("\x19Ethereum Signed Message:\n" || len(someMessage) || someMessage)
• An EIP-712 hash: keccak256("\x19\x01" || someDomainSeparator || hashStruct(someStruct)*

bytes32 private constant _MESSAGE_TYPEHASH = keccak256("BiconomyNexusMessage(bytes32 hash)");

address private immutable _SELF;

keccak256("PersonalSign(bytes prefixed)").

bytes32 internal constant _PERSONAL_SIGN_TYPEHASH = 0x983e65e5148e570cd828ead231ee759a8d7958721a768f93bc4483ba005c32de;

Initializes the smart account with the specified entry point.

constructor(address anEntryPoint);

Validates a user operation against a specified validator, extracted from the operation's nonce. The entryPoint calls this only if validation succeeds. Fails by returning VALIDATION_FAILED for invalid signatures. Other validation failures (e.g., nonce mismatch) should revert.

Expects the validator's address to be encoded in the upper 96 bits of the userOp's nonce. This method forwards the validation task to the extracted validator module address.

function validateUserOp(
    PackedUserOperation calldata userOp,
    bytes32 userOpHash,
    uint256 missingAccountFunds
)
    external
    virtual
    payPrefund(missingAccountFunds)
    onlyEntryPoint
    returns (uint256 validationData);

Parameters

Returns

Executes transactions in single or batch modes as specified by the execution mode.

This function handles transaction execution flexibility and is protected by the onlyEntryPointOrSelf modifier.

This function also goes through hook checks via withHook modifier.

function execute(ExecutionMode mode, bytes calldata executionCalldata) external payable onlyEntryPointOrSelf withHook;

Parameters

Executes transactions from an executor module, supporting both single and batch transactions.

This function is callable only by an executor module and goes through hook checks.

function executeFromExecutor(
    ExecutionMode mode,
    bytes calldata executionCalldata
)
    external
    payable
    onlyExecutorModule
    withHook
    returns (bytes[] memory returnData);

Parameters

Returns

Executes a user operation via a call using the contract's context.

Only callable by the EntryPoint. Decodes the user operation calldata, skipping the first four bytes, and executes the inner call.

function executeUserOp(PackedUserOperation calldata userOp, bytes32) external payable virtual onlyEntryPoint;

Parameters

Installs a new module to the smart account.

This function can only be called by the EntryPoint or the account itself for security reasons.

This function also goes through hook checks via withHook modifier.

function installModule(uint256 moduleTypeId, address module, bytes calldata initData) external payable onlyEntryPointOrSelf withHook;

Parameters

Uninstalls a module from the smart account.

Ensures that the operation is authorized and valid before proceeding with the uninstallation.

function uninstallModule(uint256 moduleTypeId, address module, bytes calldata deInitData) external payable onlyEntryPointOrSelf;

Parameters

Initializes the account with provided data.

function initializeAccount(bytes calldata initData) external payable virtual;

Validates a signature according to ERC-1271 standards.

Delegates the validation to a validator module specified within the signature data.

function isValidSignature(bytes32 hash, bytes calldata data) external view virtual override returns (bytes4);

Parameters

Returns

Retrieves the address of the current implementation from the EIP-1967 slot.

Checks the 1967 implementation slot, if not found then checks the slot defined by address (Biconomy V2 smart account).

function getImplementation() external view returns (address implementation);

Returns

Checks if a specific module type is supported by this smart account.

function supportsModule(uint256 moduleTypeId) external view virtual returns (bool);

Parameters

Returns

Determines if a specific execution mode is supported.

function supportsExecutionMode(ExecutionMode mode) external view virtual returns (bool isSupported);

Parameters

Returns

Determines whether a module is installed on the smart account.

function isModuleInstalled(uint256 moduleTypeId, address module, bytes calldata additionalContext) external view returns (bool);

Parameters

Returns

EIP712 hashTypedData method.

function hashTypedData(bytes32 structHash) external view returns (bytes32);

EIP712 domain separator.

function DOMAIN_SEPARATOR() external view returns (bytes32);

Returns the account's implementation ID.

function accountId() external pure virtual returns (string memory);

Returns

Upgrades the contract to a new implementation and calls a function on the new contract.

Updates two slots:

1. ERC1967 slot and
2. address() slot in case if it's potentially upgraded earlier from Biconomy V2 account, as Biconomy v2 Account (proxy) reads implementation from the slot that is defined by its address.

function upgradeToAndCall(address newImplementation, bytes calldata data) public payable virtual override onlyEntryPointOrSelf;

Parameters

Wrapper around _eip712Hash() to produce a replay-safe hash from the given hash.

The returned EIP-712 compliant replay-safe hash is the result of: keccak256( \x19\x01 || this.domainSeparator || hashStruct(BiconomyNexusMessage({ hash: hash})) )

function replaySafeHash(bytes32 hash) public view virtual returns (bytes32);

Parameters

Returns

Ensures that only authorized callers can upgrade the smart contract implementation. This is part of the UUPS (Universal Upgradeable Proxy Standard) pattern.

function _authorizeUpgrade(address newImplementation) internal virtual override(UUPSUpgradeable) onlyEntryPointOrSelf;

Parameters

Returns the EIP-712 typed hash of the BiconomyNexusMessage(bytes32 hash) data structure.

Implements encode(domainSeparator : 𝔹²⁵⁶, message : 𝕊) = "\x19\x01" || domainSeparator || hashStruct(message).

See https://eips.ethereum.org/EIPS/eip-712#specification.

function _eip712Hash(bytes32 hash) internal view virtual returns (bytes32);

Parameters

Returns

ERC1271 signature validation (Nested EIP-712 workflow). This implementation uses a nested EIP-712 approach to prevent signature replays when a single signer owns multiple smart contract accounts, while still enabling wallet UIs (e.g. Metamask) to show the EIP-712 values. Crafted for phishing resistance, efficiency, flexibility.

function _erc1271HashForIsValidSignatureViaNestedEIP712(
    bytes32 hash,
    bytes calldata signature
)
    internal
    view
    virtual
    returns (bytes32, bytes calldata);

Parameters

Returns

EIP712 domain name and version.

function _domainNameAndVersion() internal pure override returns (string memory name, string memory version);

Returns

Executes a single transaction based on the specified execution type.

function _handleSingleExecution(bytes calldata executionCalldata, ExecType execType) private;

Parameters

Executes a batch of transactions based on the specified execution type.

function _handleBatchExecution(bytes calldata executionCalldata, ExecType execType) private;

Parameters

Checks if a module is installed on the smart account.

function _isModuleInstalled(uint256 moduleTypeId, address module, bytes calldata additionalContext) private view returns (bool);

Parameters

Returns

For use in _erc1271HashForIsValidSignatureViaNestedEIP712

function _typedDataSignFields() private view returns (bytes32 m);