Account

import "@thirdweb-dev/contracts/smart-wallet/non-upgradeable/Account.sol";

This contract inherits from the BaseAccount contract

The Account smart contract is a non-upgradable, simple smart account that comes with all the basic benefits of account abstraction, alongside the default features:

• Have multiple owners
• Execute transactions (single and batched).
• Send and receive native tokens.
• Send and receive ERC-721 and ERC-1155 NFTs.
• Multicall-able.
• Store contract metadata.

Developers should use this wallet if they do not anticipate making any future upgrades to their users’ wallets.

App developers can issue Account smart accounts programmatically by deploying an AccountFactory smart contract.

Once deployed, you can use the features made available by these extensions on the SDK and dashboard:

Click on each feature to learn more about what functions are available.

• SmartWallet
• Multicall

Import the contract and inherit from it. This is an example contract demonstrating one way that you could override the functionality to create a token bound account.

import "@thirdweb-dev/contracts/smart-wallet/non-upgradable/Account.sol";
import "@thirdweb-dev/contracts/eip/interface/IERC721.sol";
 
contract TokenBoundAccount is Account {
    uint256 chainId;
    address tokenContract;
    uint256 tokenId;
 
    constructor(
        IEntryPoint _entrypoint,
        address _factory
    ) Account(_entrypoint, _factory) {
        _disableInitializers();
    }
 
    function isValidSigner(
        address _signer
    ) public view override returns (bool) {
        return (isOwner(_signer));
    }
 
    function isOwner(address _signer) public view returns (bool) {
        if (chainId != block.chainid) {
            revert("Invalid chainId");
        }
        return _signer == IERC721(tokenContract).ownerOf(tokenId);
    }
 
    function initialize(
        address _admin,
        bytes calldata _data
    ) public override initializer {
        super.initialize(_admin);
        (chainId, tokenContract, tokenId) = abi.decode(
            _data,
            (uint256, address, uint256)
        );
    }
}

The following functions have been implemented on this contract & are available to be overridden to add custom logic:

function initialize(address _defaultAdmin, bytes calldata _data) public virtual initializer {
    _setupRole(DEFAULT_ADMIN_ROLE, _defaultAdmin);
}

function getImplementationForFunction(bytes4 _functionSelector) public view virtual override returns (address) {
    address impl = getExtensionForFunction(_functionSelector).implementation;
    return impl != address(0) ? impl : defaultExtension;
}

function isValidSigner(address _signer) public view virtual returns (bool) {
    return _hasRole(SIGNER_ROLE, _signer) || _hasRole(DEFAULT_ADMIN_ROLE, _signer);
}

function entryPoint() public view virtual override returns (IEntryPoint) {
    return entrypointContract;
}

function _canSetExtension() internal view virtual override returns (bool) {
    return _hasRole(EXTENSION_ADMIN_ROLE, msg.sender);
}

function _validateSignature(UserOperation calldata userOp, bytes32 userOpHash)
    internal
    virtual
    override
    returns (uint256 validationData)
{
    bytes32 hash = userOpHash.toEthSignedMessageHash();
    address signer = hash.recover(userOp.signature);
 
    if (!isValidSigner(signer)) return SIG_VALIDATION_FAILED;
    return 0;
}